Add proper unit tests for double-dispatch pattern

double-dispatch/pom.xml

@@ -14,5 +14,10 @@
       <artifactId>junit</artifactId>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>org.mockito</groupId>
+      <artifactId>mockito-core</artifactId>
+      <scope>test</scope>
+    </dependency>
   </dependencies>
 </project>

double-dispatch/src/test/java/com/iluwatar/doubledispatch/CollisionTest.java

@@ -0,0 +1,136 @@
+package com.iluwatar.doubledispatch;
+
+import org.junit.After;
+import org.junit.Before;
+
+import java.io.PrintStream;
+import java.util.Objects;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+/**
+ * Date: 12/10/15 - 8:37 PM
+ *
+ * @author Jeroen Meulemeester
+ */
+public abstract class CollisionTest<O extends GameObject> {
+
+  /**
+   * The mocked standard out {@link PrintStream}, required if some of the actions on the tested
+   * object don't have a direct influence on any other accessible objects, except for writing to
+   * std-out using {@link System#out}
+   */
+  private final PrintStream stdOutMock = mock(PrintStream.class);
+
+  /**
+   * Keep the original std-out so it can be restored after the test
+   */
+  private final PrintStream stdOutOrig = System.out;
+
+  /**
+   * Inject the mocked std-out {@link PrintStream} into the {@link System} class before each test
+   */
+  @Before
+  public void setUp() {
+    System.setOut(this.stdOutMock);
+  }
+
+  /**
+   * Removed the mocked std-out {@link PrintStream} again from the {@link System} class
+   */
+  @After
+  public void tearDown() {
+    System.setOut(this.stdOutOrig);
+  }
+
+  /**
+   * Get the mocked stdOut {@link PrintStream}
+   *
+   * @return The stdOut print stream mock, renewed before each test
+   */
+  final PrintStream getStdOutMock() {
+    return this.stdOutMock;
+  }
+
+  /**
+   * Get the tested object
+   *
+   * @return The tested object, should never return 'null'
+   */
+  abstract O getTestedObject();
+
+  /**
+   * Collide the tested item with the other given item and verify if the damage and fire state is as
+   * expected
+   *
+   * @param other        The other object we have to collide with
+   * @param otherDamaged Indicates if the other object should be damaged after the collision
+   * @param otherOnFire  Indicates if the other object should be burning after the collision
+   * @param thisDamaged  Indicates if the test object should be damaged after the collision
+   * @param thisOnFire   Indicates if the other object should be burning after the collision
+   * @param description  The expected description of the collision
+   */
+  void testCollision(final GameObject other, final boolean otherDamaged, final boolean otherOnFire,
+                     final boolean thisDamaged, final boolean thisOnFire, final String description) {
+
+    Objects.requireNonNull(other);
+    Objects.requireNonNull(getTestedObject());
+
+    final O tested = getTestedObject();
+
+    tested.collision(other);
+
+    verify(getStdOutMock(), times(1)).println(description);
+    verifyNoMoreInteractions(getStdOutMock());
+
+    testOnFire(other, tested, otherOnFire);
+    testDamaged(other, tested, otherDamaged);
+
+    testOnFire(tested, other, thisOnFire);
+    testDamaged(tested, other, thisDamaged);
+
+  }
+
+  /**
+   * Test if the fire state of the target matches the expected state after colliding with the given
+   * object
+   *
+   * @param target             The target object
+   * @param other              The other object
+   * @param expectTargetOnFire The expected state of fire on the target object
+   */
+  private void testOnFire(final GameObject target, final GameObject other, final boolean expectTargetOnFire) {
+    final String targetName = target.getClass().getSimpleName();
+    final String otherName = other.getClass().getSimpleName();
+
+    final String errorMessage = expectTargetOnFire ?
+        "Expected [" + targetName + "] to be on fire after colliding with [" + otherName + "] but it was not!" :
+        "Expected [" + targetName + "] not to be on fire after colliding with [" + otherName + "] but it was!";
+
+    assertEquals(errorMessage, expectTargetOnFire, target.isOnFire());
+  }
+
+  /**
+   * Test if the damage state of the target matches the expected state after colliding with the
+   * given object
+   *
+   * @param target         The target object
+   * @param other          The other object
+   * @param expectedDamage The expected state of damage on the target object
+   */
+  private void testDamaged(final GameObject target, final GameObject other, final boolean expectedDamage) {
+    final String targetName = target.getClass().getSimpleName();
+    final String otherName = other.getClass().getSimpleName();
+
+    final String errorMessage = expectedDamage ?
+        "Expected [" + targetName + "] to be damaged after colliding with [" + otherName + "] but it was not!" :
+        "Expected [" + targetName + "] not to be damaged after colliding with [" + otherName + "] but it was!";
+
+    assertEquals(errorMessage, expectedDamage, target.isDamaged());
+  }
+
+}

double-dispatch/src/test/java/com/iluwatar/doubledispatch/FlamingAsteroidTest.java

@@ -0,0 +1,88 @@
+package com.iluwatar.doubledispatch;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Date: 12/10/15 - 11:31 PM
+ *
+ * @author Jeroen Meulemeester
+ */
+public class FlamingAsteroidTest extends CollisionTest<FlamingAsteroid> {
+
+  @Override
+  final FlamingAsteroid getTestedObject() {
+    return new FlamingAsteroid(1, 2, 3, 4);
+  }
+
+  /**
+   * Test the constructor parameters
+   */
+  @Test
+  public void testConstructor() {
+    final FlamingAsteroid asteroid = new FlamingAsteroid(1, 2, 3, 4);
+    assertEquals(1, asteroid.getLeft());
+    assertEquals(2, asteroid.getTop());
+    assertEquals(3, asteroid.getRight());
+    assertEquals(4, asteroid.getBottom());
+    assertTrue(asteroid.isOnFire());
+    assertFalse(asteroid.isDamaged());
+    assertEquals("FlamingAsteroid at [1,2,3,4] damaged=false onFire=true", asteroid.toString());
+  }
+
+  /**
+   * Test what happens we collide with an asteroid
+   */
+  @Test
+  public void testCollideFlamingAsteroid() {
+    testCollision(
+        new FlamingAsteroid(1, 2, 3, 4),
+        false, true,
+        false, true,
+        "FlamingAsteroid hits FlamingAsteroid."
+    );
+  }
+
+  /**
+   * Test what happens we collide with an meteoroid
+   */
+  @Test
+  public void testCollideMeteoroid() {
+    testCollision(
+        new Meteoroid(1, 1, 3, 4),
+        false, false,
+        false, true,
+        "FlamingAsteroid hits Meteoroid."
+    );
+  }
+
+  /**
+   * Test what happens we collide with ISS
+   */
+  @Test
+  public void testCollideSpaceStationIss() {
+    testCollision(
+        new SpaceStationIss(1, 1, 3, 4),
+        true, true,
+        false, true,
+        "FlamingAsteroid hits SpaceStationIss. SpaceStationIss is damaged! SpaceStationIss is set on fire!"
+    );
+  }
+
+  /**
+   * Test what happens we collide with MIR
+   */
+  @Test
+  public void testCollideSpaceStationMir() {
+    testCollision(
+        new SpaceStationMir(1, 1, 3, 4),
+        true, true,
+        false, true,
+        "FlamingAsteroid hits SpaceStationMir. SpaceStationMir is damaged! SpaceStationMir is set on fire!"
+    );
+  }
+
+}

double-dispatch/src/test/java/com/iluwatar/doubledispatch/MeteoroidTest.java

@@ -0,0 +1,87 @@
+package com.iluwatar.doubledispatch;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+/**
+ * Date: 12/10/15 - 11:31 PM
+ *
+ * @author Jeroen Meulemeester
+ */
+public class MeteoroidTest extends CollisionTest<Meteoroid> {
+
+  @Override
+  final Meteoroid getTestedObject() {
+    return new Meteoroid(1, 2, 3, 4);
+  }
+
+  /**
+   * Test the constructor parameters
+   */
+  @Test
+  public void testConstructor() {
+    final Meteoroid meteoroid = new Meteoroid(1, 2, 3, 4);
+    assertEquals(1, meteoroid.getLeft());
+    assertEquals(2, meteoroid.getTop());
+    assertEquals(3, meteoroid.getRight());
+    assertEquals(4, meteoroid.getBottom());
+    assertFalse(meteoroid.isOnFire());
+    assertFalse(meteoroid.isDamaged());
+    assertEquals("Meteoroid at [1,2,3,4] damaged=false onFire=false", meteoroid.toString());
+  }
+
+  /**
+   * Test what happens we collide with an asteroid
+   */
+  @Test
+  public void testCollideFlamingAsteroid() {
+    testCollision(
+        new FlamingAsteroid(1, 1, 3, 4),
+        false, true,
+        false, false,
+        "Meteoroid hits FlamingAsteroid."
+    );
+  }
+
+  /**
+   * Test what happens we collide with an meteoroid
+   */
+  @Test
+  public void testCollideMeteoroid() {
+    testCollision(
+        new Meteoroid(1, 1, 3, 4),
+        false, false,
+        false, false,
+        "Meteoroid hits Meteoroid."
+    );
+  }
+
+  /**
+   * Test what happens we collide with ISS
+   */
+  @Test
+  public void testCollideSpaceStationIss() {
+    testCollision(
+        new SpaceStationIss(1, 1, 3, 4),
+        true, false,
+        false, false,
+        "Meteoroid hits SpaceStationIss. SpaceStationIss is damaged!"
+    );
+  }
+
+  /**
+   * Test what happens we collide with MIR
+   */
+  @Test
+  public void testCollideSpaceStationMir() {
+    testCollision(
+        new SpaceStationMir(1, 1, 3, 4),
+        true, false,
+        false, false,
+        "Meteoroid hits SpaceStationMir. SpaceStationMir is damaged!"
+    );
+  }
+
+}

double-dispatch/src/test/java/com/iluwatar/doubledispatch/RectangleTest.java

@@ -1,22 +1,47 @@
 package com.iluwatar.doubledispatch;
 
-import org.junit.Assert;
 import org.junit.Test;
 
-import com.iluwatar.doubledispatch.Rectangle;
+import static junit.framework.TestCase.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 
 /**
- * 
  * Unit test for Rectangle
- *
  */
 public class RectangleTest {
 
+  /**
+   * Test if the values passed through the constructor matches the values fetched from the getters
+   */
   @Test
-  public void test() {
-    Assert.assertTrue(new Rectangle(0, 0, 1, 1).intersectsWith(new Rectangle(0, 0, 1, 1)));
-    Assert.assertTrue(new Rectangle(0, 0, 1, 1).intersectsWith(new Rectangle(-1, -5, 7, 8)));
-    Assert.assertFalse(new Rectangle(0, 0, 1, 1).intersectsWith(new Rectangle(2, 2, 3, 3)));
-    Assert.assertFalse(new Rectangle(0, 0, 1, 1).intersectsWith(new Rectangle(-2, -2, -1, -1)));
+  public void testConstructor() {
+    final Rectangle rectangle = new Rectangle(1, 2, 3, 4);
+    assertEquals(1, rectangle.getLeft());
+    assertEquals(2, rectangle.getTop());
+    assertEquals(3, rectangle.getRight());
+    assertEquals(4, rectangle.getBottom());
   }
+
+  /**
+   * Test if the values passed through the constructor matches the values in the {@link
+   * #toString()}
+   */
+  @Test
+  public void testToString() throws Exception {
+    final Rectangle rectangle = new Rectangle(1, 2, 3, 4);
+    assertEquals("[1,2,3,4]", rectangle.toString());
+  }
+
+  /**
+   * Test if the {@link Rectangle} class can detect if it intersects with another rectangle.
+   */
+  @Test
+  public void testIntersection() {
+    assertTrue(new Rectangle(0, 0, 1, 1).intersectsWith(new Rectangle(0, 0, 1, 1)));
+    assertTrue(new Rectangle(0, 0, 1, 1).intersectsWith(new Rectangle(-1, -5, 7, 8)));
+    assertFalse(new Rectangle(0, 0, 1, 1).intersectsWith(new Rectangle(2, 2, 3, 3)));
+    assertFalse(new Rectangle(0, 0, 1, 1).intersectsWith(new Rectangle(-2, -2, -1, -1)));
+  }
+
 }

double-dispatch/src/test/java/com/iluwatar/doubledispatch/SpaceStationIssTest.java

@@ -0,0 +1,87 @@
+package com.iluwatar.doubledispatch;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+/**
+ * Date: 12/10/15 - 11:31 PM
+ *
+ * @author Jeroen Meulemeester
+ */
+public class SpaceStationIssTest extends CollisionTest<SpaceStationIss> {
+
+  @Override
+  final SpaceStationIss getTestedObject() {
+    return new SpaceStationIss(1, 2, 3, 4);
+  }
+
+  /**
+   * Test the constructor parameters
+   */
+  @Test
+  public void testConstructor() {
+    final SpaceStationIss iss = new SpaceStationIss(1, 2, 3, 4);
+    assertEquals(1, iss.getLeft());
+    assertEquals(2, iss.getTop());
+    assertEquals(3, iss.getRight());
+    assertEquals(4, iss.getBottom());
+    assertFalse(iss.isOnFire());
+    assertFalse(iss.isDamaged());
+    assertEquals("SpaceStationIss at [1,2,3,4] damaged=false onFire=false", iss.toString());
+  }
+
+  /**
+   * Test what happens we collide with an asteroid
+   */
+  @Test
+  public void testCollideFlamingAsteroid() {
+    testCollision(
+        new FlamingAsteroid(1, 1, 3, 4),
+        false, true,
+        false, false,
+        "SpaceStationIss hits FlamingAsteroid."
+    );
+  }
+
+  /**
+   * Test what happens we collide with an meteoroid
+   */
+  @Test
+  public void testCollideMeteoroid() {
+    testCollision(
+        new Meteoroid(1, 1, 3, 4),
+        false, false,
+        false, false,
+        "SpaceStationIss hits Meteoroid."
+    );
+  }
+
+  /**
+   * Test what happens we collide with ISS
+   */
+  @Test
+  public void testCollideSpaceStationIss() {
+    testCollision(
+        new SpaceStationIss(1, 1, 3, 4),
+        true, false,
+        false, false,
+        "SpaceStationIss hits SpaceStationIss. SpaceStationIss is damaged!"
+    );
+  }
+
+  /**
+   * Test what happens we collide with MIR
+   */
+  @Test
+  public void testCollideSpaceStationMir() {
+    testCollision(
+        new SpaceStationMir(1, 1, 3, 4),
+        true, false,
+        false, false,
+        "SpaceStationIss hits SpaceStationMir. SpaceStationMir is damaged!"
+    );
+  }
+
+}

double-dispatch/src/test/java/com/iluwatar/doubledispatch/SpaceStationMirTest.java

@@ -0,0 +1,87 @@
+package com.iluwatar.doubledispatch;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+/**
+ * Date: 12/10/15 - 11:31 PM
+ *
+ * @author Jeroen Meulemeester
+ */
+public class SpaceStationMirTest extends CollisionTest<SpaceStationMir> {
+
+  @Override
+  final SpaceStationMir getTestedObject() {
+    return new SpaceStationMir(1, 2, 3, 4);
+  }
+
+  /**
+   * Test the constructor parameters
+   */
+  @Test
+  public void testConstructor() {
+    final SpaceStationMir mir = new SpaceStationMir(1, 2, 3, 4);
+    assertEquals(1, mir.getLeft());
+    assertEquals(2, mir.getTop());
+    assertEquals(3, mir.getRight());
+    assertEquals(4, mir.getBottom());
+    assertFalse(mir.isOnFire());
+    assertFalse(mir.isDamaged());
+    assertEquals("SpaceStationMir at [1,2,3,4] damaged=false onFire=false", mir.toString());
+  }
+
+  /**
+   * Test what happens we collide with an asteroid
+   */
+  @Test
+  public void testCollideFlamingAsteroid() {
+    testCollision(
+        new FlamingAsteroid(1, 1, 3, 4),
+        false, true,
+        false, false,
+        "SpaceStationMir hits FlamingAsteroid."
+    );
+  }
+
+  /**
+   * Test what happens we collide with an meteoroid
+   */
+  @Test
+  public void testCollideMeteoroid() {
+    testCollision(
+        new Meteoroid(1, 1, 3, 4),
+        false, false,
+        false, false,
+        "SpaceStationMir hits Meteoroid."
+    );
+  }
+
+  /**
+   * Test what happens we collide with ISS
+   */
+  @Test
+  public void testCollideSpaceStationIss() {
+    testCollision(
+        new SpaceStationIss(1, 1, 3, 4),
+        true, false,
+        false, false,
+        "SpaceStationMir hits SpaceStationIss. SpaceStationIss is damaged!"
+    );
+  }
+
+  /**
+   * Test what happens we collide with MIR
+   */
+  @Test
+  public void testCollideSpaceStationMir() {
+    testCollision(
+        new SpaceStationMir(1, 1, 3, 4),
+        true, false,
+        false, false,
+        "SpaceStationMir hits SpaceStationMir. SpaceStationMir is damaged!"
+    );
+  }
+
+}