Merge pull request #184 from stkent/robot-simulator

robot-simulator: add to track

config.json

@@ -48,7 +48,8 @@
     "largest-series-product",
     "queen-attack",
     "minesweeper",
-    "series"
+    "series",
+    "robot-simulator"
   ],
   "exercises": [
     {
@@ -275,6 +276,11 @@
       "slug": "series",
       "difficulty": 1,
       "topics": []
+    },
+    {
+      "slug": "robot-simulator",
+      "difficulty": 1,
+      "topics": []
     }
   ],
   "deprecated": [

exercises/robot-simulator/build.gradle

@@ -0,0 +1,17 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  testCompile "junit:junit:4.12"
+}
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/robot-simulator/src/example/java/GridPosition.java

@@ -0,0 +1 @@
+../../main/java/GridPosition.java

exercises/robot-simulator/src/example/java/Orientation.java

@@ -0,0 +1 @@
+../../main/java/Orientation.java

exercises/robot-simulator/src/example/java/Robot.java

@@ -0,0 +1,71 @@
+final class Robot {
+
+    private GridPosition gridPosition;
+
+    private Orientation orientation;
+
+    Robot(final GridPosition initialGridPosition, final Orientation initialOrientation) {
+        this.gridPosition = initialGridPosition;
+        this.orientation = initialOrientation;
+    }
+
+    GridPosition getGridPosition() {
+        return gridPosition;
+    }
+
+    Orientation getOrientation() {
+        return orientation;
+    }
+
+    Robot advance() {
+        switch (orientation) {
+            case NORTH:
+                gridPosition = new GridPosition(gridPosition.x, gridPosition.y + 1);
+                break;
+            case EAST:
+                gridPosition = new GridPosition(gridPosition.x + 1, gridPosition.y);
+                break;
+            case SOUTH:
+                gridPosition = new GridPosition(gridPosition.x, gridPosition.y - 1);
+                break;
+            case WEST:
+                gridPosition = new GridPosition(gridPosition.x - 1, gridPosition.y);
+                break;
+        }
+
+        return this;
+    }
+
+    Robot simulate(final String instructions) {
+        for (final char instruction : instructions.toCharArray()) {
+            switch (instruction) {
+                case 'A':
+                    advance();
+                    break;
+                case 'R':
+                    turnRight();
+                    break;
+                case 'L':
+                    turnLeft();
+                    break;
+                default:
+                    throw new IllegalArgumentException(String.format("Invalid instruction: '%s'", instruction));
+            }
+        }
+
+        return this;
+    }
+
+    Robot turnLeft() {
+        final int newOrientationOrdinal = Math.floorMod(orientation.ordinal() - 1, Orientation.values().length);
+        orientation = Orientation.values()[newOrientationOrdinal];
+        return this;
+    }
+
+    Robot turnRight() {
+        final int newOrientationOrdinal = Math.floorMod(orientation.ordinal() + 1, Orientation.values().length);
+        orientation = Orientation.values()[newOrientationOrdinal];
+        return this;
+    }
+
+}

exercises/robot-simulator/src/main/java/GridPosition.java

@@ -0,0 +1,29 @@
+final class GridPosition {
+
+    final int x;
+
+    final int y;
+
+    GridPosition(final int x, final int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    /*
+     * This equals method is of deliberately narrow scope (only allows comparison with another GridPosition) to increase
+     * readability. In general, one should provide a full implementation of Object.equals(Object obj) and a
+     * corresponding implementation of Object.hashCode(). See
+     *
+     * https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#equals(java.lang.Object)
+     *
+     * and
+     *
+     * https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html#hashCode()
+     *
+     * for more information.
+     */
+    boolean equals(final GridPosition gridPosition) {
+        return this.x == gridPosition.x && this.y == gridPosition.y;
+    }
+
+}

exercises/robot-simulator/src/main/java/Orientation.java

@@ -0,0 +1,5 @@
+enum Orientation {
+
+    NORTH, EAST, SOUTH, WEST
+
+}

exercises/robot-simulator/src/main/java/Robot.java

@@ -0,0 +1,5 @@
+final class Robot {
+
+
+
+}

exercises/robot-simulator/src/test/java/RobotTest.java

@@ -0,0 +1,244 @@
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.assertTrue;
+
+public final class RobotTest {
+
+    @Test
+    public void testRobotIsCreatedWithCorrectInitialPosition() {
+        final GridPosition initialGridPosition = new GridPosition(0, 0);
+        final Robot robot = new Robot(initialGridPosition, Orientation.NORTH);
+
+        assertTrue(robot.getGridPosition().equals(initialGridPosition));
+    }
+
+    @Ignore
+    @Test
+    public void testRobotIsCreatedWithCorrectInitialOrientation() {
+        final Orientation initialOrientation = Orientation.NORTH;
+        final Robot robot = new Robot(new GridPosition(0, 0), initialOrientation);
+
+        assertTrue(robot.getOrientation().equals(initialOrientation));
+    }
+
+    @Ignore
+    @Test
+    public void testTurningRightDoesNotChangePosition() {
+        final GridPosition initialGridPosition = new GridPosition(0, 0);
+        final Robot robot = new Robot(initialGridPosition, Orientation.NORTH);
+
+        robot.turnRight();
+
+        assertTrue(robot.getGridPosition().equals(initialGridPosition));
+    }
+
+    @Ignore
+    @Test
+    public void testTurningRightCorrectlyChangesOrientationFromNorthToEast() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.NORTH);
+
+        robot.turnRight();
+
+        final Orientation expectedOrientation = Orientation.EAST;
+
+        assertTrue(robot.getOrientation().equals(expectedOrientation));
+    }
+
+    @Ignore
+    @Test
+    public void testTurningRightCorrectlyChangesOrientationFromEastToSouth() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.EAST);
+
+        robot.turnRight();
+
+        final Orientation expectedOrientation = Orientation.SOUTH;
+
+        assertTrue(robot.getOrientation().equals(expectedOrientation));
+    }
+
+    @Ignore
+    @Test
+    public void testTurningRightCorrectlyChangesOrientationFromSouthToWest() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.SOUTH);
+
+        robot.turnRight();
+
+        final Orientation expectedOrientation = Orientation.WEST;
+
+        assertTrue(robot.getOrientation().equals(expectedOrientation));
+    }
+
+    @Ignore
+    @Test
+    public void testTurningRightCorrectlyChangesOrientationFromWestToNorth() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.WEST);
+
+        robot.turnRight();
+
+        final Orientation expectedOrientation = Orientation.NORTH;
+
+        assertTrue(robot.getOrientation().equals(expectedOrientation));
+    }
+
+    @Ignore
+    @Test
+    public void testTurningLeftDoesNotChangePosition() {
+        final GridPosition initialGridPosition = new GridPosition(0, 0);
+        final Robot robot = new Robot(initialGridPosition, Orientation.NORTH);
+
+        robot.turnLeft();
+
+        assertTrue(robot.getGridPosition().equals(initialGridPosition));
+    }
+
+    @Ignore
+    @Test
+    public void testTurningLeftCorrectlyChangesOrientationFromNorthToWest() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.NORTH);
+
+        robot.turnLeft();
+
+        final Orientation expectedOrientation = Orientation.WEST;
+
+        assertTrue(robot.getOrientation().equals(expectedOrientation));
+    }
+
+    @Ignore
+    @Test
+    public void testTurningLeftCorrectlyChangesOrientationFromWestToSouth() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.WEST);
+
+        robot.turnLeft();
+
+        final Orientation expectedOrientation = Orientation.SOUTH;
+
+        assertTrue(robot.getOrientation().equals(expectedOrientation));
+    }
+
+    @Ignore
+    @Test
+    public void testTurningLeftCorrectlyChangesOrientationFromSouthToEast() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.SOUTH);
+
+        robot.turnLeft();
+
+        final Orientation expectedOrientation = Orientation.EAST;
+
+        assertTrue(robot.getOrientation().equals(expectedOrientation));
+    }
+
+    @Ignore
+    @Test
+    public void testTurningLeftCorrectlyChangesOrientationFromEastToNorth() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.EAST);
+
+        robot.turnLeft();
+
+        final Orientation expectedOrientation = Orientation.NORTH;
+
+        assertTrue(robot.getOrientation().equals(expectedOrientation));
+    }
+
+    @Ignore
+    @Test
+    public void testAdvancingDoesNotChangeOrientation() {
+        final Orientation initialOrientation = Orientation.NORTH;
+        final Robot robot = new Robot(new GridPosition(0, 0), initialOrientation);
+
+        robot.advance();
+
+        assertTrue(robot.getOrientation().equals(initialOrientation));
+    }
+
+    @Ignore
+    @Test
+    public void testAdvancingWhenFacingNorthIncreasesYCoordinateByOne() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.NORTH);
+
+        robot.advance();
+
+        final GridPosition expectedGridPosition = new GridPosition(0, 1);
+
+        assertTrue(robot.getGridPosition().equals(expectedGridPosition));
+    }
+
+    @Ignore
+    @Test
+    public void testAdvancingWhenFacingSouthDecreasesYCoordinateByOne() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.SOUTH);
+
+        robot.advance();
+
+        final GridPosition expectedGridPosition = new GridPosition(0, -1);
+
+        assertTrue(robot.getGridPosition().equals(expectedGridPosition));
+    }
+
+    @Ignore
+    @Test
+    public void testAdvancingWhenFacingEastIncreasesXCoordinateByOne() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.EAST);
+
+        robot.advance();
+
+        final GridPosition expectedGridPosition = new GridPosition(1, 0);
+
+        assertTrue(robot.getGridPosition().equals(expectedGridPosition));
+    }
+
+    @Ignore
+    @Test
+    public void testAdvancingWhenFacingWestDecreasesXCoordinateByOne() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.WEST);
+
+        robot.advance();
+
+        final GridPosition expectedGridPosition = new GridPosition(-1, 0);
+
+        assertTrue(robot.getGridPosition().equals(expectedGridPosition));
+    }
+
+    @Ignore
+    @Test
+    public void testInstructionsToMoveWestAndNorth() {
+        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.NORTH);
+
+        robot.simulate("LAAARALA");
+
+        final GridPosition expectedGridPosition = new GridPosition(-4, 1);
+        final Orientation expectedOrientation = Orientation.WEST;
+
+        assertTrue(robot.getGridPosition().equals(expectedGridPosition));
+        assertTrue(robot.getOrientation().equals(expectedOrientation));
+    }
+
+    @Ignore
+    @Test
+    public void testInstructionsToMoveWestAndSouth() {
+        final Robot robot = new Robot(new GridPosition(2, -7), Orientation.EAST);
+
+        robot.simulate("RRAAAAALA");
+
+        final GridPosition expectedGridPosition = new GridPosition(-3, -8);
+        final Orientation expectedOrientation = Orientation.SOUTH;
+
+        assertTrue(robot.getGridPosition().equals(expectedGridPosition));
+        assertTrue(robot.getOrientation().equals(expectedOrientation));
+    }
+
+    @Ignore
+    @Test
+    public void testInstructionsToMoveEastAndNorth() {
+        final Robot robot = new Robot(new GridPosition(8, 4), Orientation.SOUTH);
+
+        robot.simulate("LAAARRRALLLL");
+
+        final GridPosition expectedGridPosition = new GridPosition(11, 5);
+        final Orientation expectedOrientation = Orientation.NORTH;
+
+        assertTrue(robot.getGridPosition().equals(expectedGridPosition));
+        assertTrue(robot.getOrientation().equals(expectedOrientation));
+    }
+
+}

exercises/settings.gradle

@@ -30,6 +30,7 @@ include 'queen-attack'
 include 'raindrops'
 include 'rna-transcription'
 include 'robot-name'
+include 'robot-simulator'
 include 'roman-numerals'
 include 'prime-factors'
 include 'scrabble-score'