Add unit tests

Author: Azureyjt

update-method/pom.xml

@@ -33,6 +33,12 @@
     <modelVersion>4.0.0</modelVersion>
 
     <artifactId>update-method</artifactId>
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+        </dependency>
+    </dependencies>
 
 
 </project>

update-method/src/main/java/com/iluwatar/updatemethod/App.java

@@ -23,16 +23,37 @@
 
 package com.iluwatar.updatemethod;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * This pattern simulate a collection of independent objects by telling each to
+ * process one frame of behavior at a time. The game world maintains a collection
+ * of objects. Each object implements an update method that simulates one frame of
+ * the object’s behavior. Each frame, the game updates every object in the collection.
+ */
 public class App {
 
+  private static final Logger LOGGER = LoggerFactory.getLogger(App.class);
+
+  /**
+   * Program entry point.
+   * @param args runtime arguments
+   */
   public static void main(String[] args) {
-    var world = new World();
-    var skeleton1 = new Skeleton(1, 10);
-    var skeleton2 = new Skeleton(2, 70);
-    var statue = new Statue(3, 20);
-    world.addEntity(skeleton1);
-    world.addEntity(skeleton2);
-    world.addEntity(statue);
-    world.gameLoop();
+    try {
+      var world = new World();
+      var skeleton1 = new Skeleton(1, 10);
+      var skeleton2 = new Skeleton(2, 70);
+      var statue = new Statue(3, 20);
+      world.addEntity(skeleton1);
+      world.addEntity(skeleton2);
+      world.addEntity(statue);
+      world.run();
+      Thread.sleep(200);
+      world.stop();
+    } catch (InterruptedException e) {
+      LOGGER.error(e.getMessage());
+    }
   }
 }

update-method/src/main/java/com/iluwatar/updatemethod/Entity.java

@@ -26,6 +26,9 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+/**
+ * Abstract class for all the entity types.
+ */
 public abstract class Entity {
 
   protected final Logger logger = LoggerFactory.getLogger(this.getClass());

update-method/src/main/java/com/iluwatar/updatemethod/Skeleton.java

@@ -23,6 +23,12 @@
 
 package com.iluwatar.updatemethod;
 
+/**
+ * Skeletons are always patrolling on the game map. Initially all the skeletons
+ * patrolling to the right, and after them reach the bounding, it will start
+ * patrolling to the left. For each frame, one skeleton will move 1 position
+ * step.
+ */
 public class Skeleton extends Entity {
 
   private static final int PATROLLING_LEFT_BOUNDING = 0;
@@ -31,11 +37,22 @@ public class Skeleton extends Entity {
 
   protected boolean patrollingLeft;
 
+  /**
+   * Constructor of Skeleton.
+   *
+   * @param id id of skeleton
+   */
   public Skeleton(int id) {
     super(id);
     patrollingLeft = false;
   }
 
+  /**
+   * Constructor of Skeleton.
+   *
+   * @param id id of skeleton
+   * @param postition position of skeleton
+   */
   public Skeleton(int id, int postition) {
     super(id);
     this.position = position;
@@ -55,7 +72,7 @@ public void update() {
         patrollingLeft = true;
       }
     }
-    logger.info("Skeleton " + id + " is on position " + position);
+    logger.info("Skeleton " + id + " is on position " + position + ".");
   }
 }
 

update-method/src/main/java/com/iluwatar/updatemethod/Statue.java

@@ -23,18 +23,32 @@
 
 package com.iluwatar.updatemethod;
 
+/**
+ * Statues shoot lightning at regular intervals.
+ */
 public class Statue extends Entity {
 
   protected int frames;
 
   protected int delay;
 
+  /**
+   * Constructor of Statue.
+   *
+   * @param id id of statue
+   */
   public Statue(int id) {
     super(id);
     this.frames = 0;
     this.delay = 0;
   }
 
+  /**
+   * Constructor of Statue.
+   *
+   * @param id id of statue
+   * @param delay the number of frames between two lightning
+   */
   public Statue(int id, int delay) {
     super(id);
     this.frames = 0;
@@ -50,6 +64,6 @@ public void update() {
   }
 
   private void shootLightning() {
-    logger.info("Statue " + id + " is shooting lightning!");
+    logger.info("Statue " + id + " shoots lightning!");
   }
 }

update-method/src/main/java/com/iluwatar/updatemethod/World.java

@@ -25,33 +25,88 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Random;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * The game world class. Maintain all the objects existed in the game frames.
+ */
 public class World {
 
+  private static final Logger LOGGER = LoggerFactory.getLogger(World.class);
+
   private List<Entity> entities;
 
+  private volatile boolean isRunning;
+
   public World() {
     entities = new ArrayList<>();
+    isRunning = false;
   }
 
-  public void gameLoop() {
-    while (true) {
+  /**
+   * Main game loop. This loop will always run until the game is over. For
+   * each loop it will process user input, update internal status, and render
+   * the next frames. For more detail please refer to the game-loop pattern.
+   */
+  private void gameLoop() {
+    while (isRunning) {
       processInput();
       update();
       render();
     }
   }
 
-  private void processInput() {}
+  /**
+   * Handle any user input that has happened since the last call. In order to
+   * simulate the situation in real-life game, here we add a random time lag.
+   * The time lag ranges from 50 ms to 250 ms.
+   */
+  private void processInput() {
+    try {
+      int lag = new Random().nextInt(200) + 50;
+      Thread.sleep(lag);
+    } catch (InterruptedException e) {
+      LOGGER.error(e.getMessage());
+    }
+  }
 
+  /**
+   * Update internal status. The update method pattern invoke udpate method for
+   * each entity in the game.
+   */
   private void update() {
     for (var entity : entities) {
       entity.update();
     }
   }
 
+  /**
+   * Render the next frame. Here we do nothing since it is not related to the
+   * pattern.
+   */
   private void render() {}
 
+  /**
+   * Run game loop.
+   */
+  public void run() {
+    LOGGER.info("Start game.");
+    isRunning = true;
+    var thread = new Thread(this::gameLoop);
+    thread.start();
+  }
+
+  /**
+   * Stop game loop.
+   */
+  public void stop() {
+    LOGGER.info("Stop game.");
+    isRunning = false;
+  }
+
   public void addEntity(Entity entity) {
     entities.add(entity);
   }

update-method/src/test/java/com/iluwatar/updatemethod/AppTest.java

@@ -0,0 +1,35 @@
+/*
+ * The MIT License
+ * Copyright © 2014-2019 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.iluwatar.updatemethod;
+
+import org.junit.Test;
+
+public class AppTest {
+
+  @Test
+  public void testMain() {
+    String[] args = {};
+    App.main(args);
+  }
+}

update-method/src/test/java/com/iluwatar/updatemethod/SkeletonTest.java

@@ -0,0 +1,78 @@
+/*
+ * The MIT License
+ * Copyright © 2014-2019 Ilkka Seppälä
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package com.iluwatar.updatemethod;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class SkeletonTest {
+
+  private Skeleton skeleton;
+
+  @Before
+  public void setup() {
+    skeleton = new Skeleton(1);
+  }
+
+  @After
+  public void tearDown() {
+    skeleton = null;
+  }
+
+  @Test
+  public void testUpdateForPatrollingLeft() {
+    skeleton.patrollingLeft = true;
+    skeleton.setPosition(50);
+    skeleton.update();
+    Assert.assertEquals(49, skeleton.getPosition());
+  }
+
+  @Test
+  public void testUpdateForPatrollingRight() {
+    skeleton.patrollingLeft = false;
+    skeleton.setPosition(50);
+    skeleton.update();
+    Assert.assertEquals(51, skeleton.getPosition());
+  }
+
+  @Test
+  public void testUpdateForReverseDirectionFromLeftToRight() {
+    skeleton.patrollingLeft = true;
+    skeleton.setPosition(1);
+    skeleton.update();
+    Assert.assertEquals(0, skeleton.getPosition());
+    Assert.assertEquals(false, skeleton.patrollingLeft);
+  }
+
+  @Test
+  public void testUpdateForReverseDirectionFromRightToLeft() {
+    skeleton.patrollingLeft = false;
+    skeleton.setPosition(99);
+    skeleton.update();
+    Assert.assertEquals(100, skeleton.getPosition());
+    Assert.assertEquals(true, skeleton.patrollingLeft);
+  }
+}