Index: Ringtoets/Common/test/Ringtoets.Common.Data.Test/DikeProfiles/BreakWaterTest.cs
===================================================================
diff -u -r268c1647f0094f6c43aeceaa5793437562cffe5a -rc9c84dd1e179cb738c27a1e1b66d21fbec90da18
--- Ringtoets/Common/test/Ringtoets.Common.Data.Test/DikeProfiles/BreakWaterTest.cs	(.../BreakWaterTest.cs)	(revision 268c1647f0094f6c43aeceaa5793437562cffe5a)
+++ Ringtoets/Common/test/Ringtoets.Common.Data.Test/DikeProfiles/BreakWaterTest.cs	(.../BreakWaterTest.cs)	(revision c9c84dd1e179cb738c27a1e1b66d21fbec90da18)
@@ -20,6 +20,7 @@
 // All rights reserved.
 
 using System;
+using System.Collections.Generic;
 using Core.Common.Base.Data;
 using Core.Common.Data.TestUtil;
 using Core.Common.TestUtil;
@@ -82,168 +83,47 @@
         }
 
         [Test]
-        public void Equals_ToItself_ReturnsTrue()
+        public void Clone_Always_ReturnNewInstanceWithCopiedValues()
         {
             // Setup
-            var breakWater = new BreakWater(BreakWaterType.Caisson, 100.10);
+            var random = new Random(21);
+            var original = new BreakWater(random.NextEnumValue<BreakWaterType>(), random.NextDouble());
 
             // Call
-            bool isBreakWaterEqualToItself = breakWater.Equals(breakWater);
+            object clone = original.Clone();
 
             // Assert
-            Assert.IsTrue(isBreakWaterEqualToItself);
+            CoreCloneAssert.AreObjectClones(original, clone, CommonCloneAssert.AreClones);
         }
 
-        [Test]
-        public void Equals_AllPropertiesEqual_ReturnsTrue()
+        [TestFixture]
+        private class BreakWaterEqualsTest : EqualsGuidelinesTestFixture<BreakWater, DerivedBreakWater>
         {
-            // Setup 
-            const BreakWaterType type = BreakWaterType.Caisson;
-            const double height = 100.10;
+            private const double height = 3.14;
+            private const BreakWaterType type = BreakWaterType.Caisson;
 
-            var breakWaterOne = new BreakWater(type, height);
-            var breakWaterTwo = new BreakWater(type, height);
+            protected override BreakWater CreateObject()
+            {
+                return new BreakWater(type, height);
+            }
 
-            // Call
-            bool isBreakWaterOneEqualToTwo = breakWaterOne.Equals(breakWaterTwo);
-            bool isBreakWaterTwoEqualToOne = breakWaterTwo.Equals(breakWaterOne);
+            protected override DerivedBreakWater CreateDerivedObject()
+            {
+                return new DerivedBreakWater(type, height);
+            }
 
-            // Assert
-            Assert.IsTrue(isBreakWaterOneEqualToTwo);
-            Assert.IsTrue(isBreakWaterTwoEqualToOne);
+            private static IEnumerable<TestCaseData> GetUnequalTestCases()
+            {
+                yield return new TestCaseData(new BreakWater(BreakWaterType.Dam, height))
+                    .SetName("Type");
+                yield return new TestCaseData(new BreakWater(type, height + 10))
+                    .SetName("Height");
+            }
         }
 
-        [Test]
-        public void Equals_ToSameReference_ReturnsTrue()
+        private class DerivedBreakWater : BreakWater
         {
-            // Setup
-            var breakWaterOne = new BreakWater(BreakWaterType.Caisson, 100.10);
-            BreakWater breakWaterTwo = breakWaterOne;
-
-            // Call
-            bool isBreakWaterOneEqualToTwo = breakWaterOne.Equals(breakWaterTwo);
-            bool isBreakWaterTwoEqualToOne = breakWaterTwo.Equals(breakWaterOne);
-
-            // Assert
-            Assert.IsTrue(isBreakWaterOneEqualToTwo);
-            Assert.IsTrue(isBreakWaterTwoEqualToOne);
+            public DerivedBreakWater(BreakWaterType type, double height) : base(type, height) {}
         }
-
-        [Test]
-        public void Equals_TransitivePropertyEqualBreakWater_ReturnsTrue()
-        {
-            // Setup 
-            const BreakWaterType type = BreakWaterType.Caisson;
-            const double height = 100.10;
-
-            var breakWaterOne = new BreakWater(type, height);
-            var breakWaterTwo = new BreakWater(type, height);
-            var breakWaterThree = new BreakWater(type, height);
-
-            // Call
-            bool isBreakWaterOneEqualToTwo = breakWaterOne.Equals(breakWaterTwo);
-            bool isBreakWaterTwoEqualToThree = breakWaterTwo.Equals(breakWaterThree);
-            bool isBreakWaterOneEqualToThree = breakWaterOne.Equals(breakWaterThree);
-
-            // Assert
-            Assert.IsTrue(isBreakWaterOneEqualToTwo);
-            Assert.IsTrue(isBreakWaterTwoEqualToThree);
-            Assert.IsTrue(isBreakWaterOneEqualToThree);
-        }
-
-        [Test]
-        public void Equals_ToNull_ReturnsFalse()
-        {
-            // Setup
-            var breakWater = new BreakWater(BreakWaterType.Caisson, 100.10);
-
-            // Call
-            bool isBreakWaterEqualToNull = breakWater.Equals(null);
-
-            // Assert
-            Assert.IsFalse(isBreakWaterEqualToNull);
-        }
-
-        [Test]
-        public void Equals_ToDifferentType_ReturnsFalse()
-        {
-            // Setup
-            var breakWater = new BreakWater(BreakWaterType.Caisson, 100.10);
-            var differentType = new object();
-
-            // Call
-            bool isBreakWaterEqualToDifferentType = breakWater.Equals(differentType);
-
-            // Assert
-            Assert.IsFalse(isBreakWaterEqualToDifferentType);
-        }
-
-        [Test]
-        public void Equals_DifferentBreakWaterType_ReturnsFalse()
-        {
-            // Setup 
-            const double height = 100.10;
-
-            var breakWaterOne = new BreakWater(BreakWaterType.Caisson, height);
-            var breakWaterTwo = new BreakWater(BreakWaterType.Wall, height);
-
-            // Call
-            bool isBreakWaterOneEqualToTwo = breakWaterOne.Equals(breakWaterTwo);
-            bool isBreakWaterTwoEqualToOne = breakWaterTwo.Equals(breakWaterOne);
-
-            // Assert
-            Assert.IsFalse(isBreakWaterOneEqualToTwo);
-            Assert.IsFalse(isBreakWaterTwoEqualToOne);
-        }
-
-        [Test]
-        public void Equals_DifferentHeight_ReturnsFalse()
-        {
-            // Setup 
-            const BreakWaterType type = BreakWaterType.Caisson;
-
-            var breakWaterOne = new BreakWater(type, 100.10);
-            var breakWaterTwo = new BreakWater(type, 100.20);
-
-            // Call
-            bool isBreakWaterOneEqualToTwo = breakWaterOne.Equals(breakWaterTwo);
-            bool isBreakWaterTwoEqualToOne = breakWaterTwo.Equals(breakWaterOne);
-
-            // Assert
-            Assert.IsFalse(isBreakWaterOneEqualToTwo);
-            Assert.IsFalse(isBreakWaterTwoEqualToOne);
-        }
-
-        [Test]
-        public void GetHashCode_EqualBreakWater_ReturnsSameHashCode()
-        {
-            // Setup 
-            const BreakWaterType type = BreakWaterType.Caisson;
-            const double height = 100.10;
-
-            var breakWaterOne = new BreakWater(type, height);
-            var breakWaterTwo = new BreakWater(type, height);
-
-            // Call
-            int hashCodeOne = breakWaterOne.GetHashCode();
-            int hashCodeTwo = breakWaterTwo.GetHashCode();
-
-            // Assert
-            Assert.AreEqual(hashCodeOne, hashCodeTwo);
-        }
-
-        [Test]
-        public void Clone_Always_ReturnNewInstanceWithCopiedValues()
-        {
-            // Setup
-            var random = new Random(21);
-            var original = new BreakWater(random.NextEnumValue<BreakWaterType>(), random.NextDouble());
-
-            // Call
-            object clone = original.Clone();
-
-            // Assert
-            CoreCloneAssert.AreObjectClones(original, clone, CommonCloneAssert.AreClones);
-        }
     }
 }
\ No newline at end of file