Merged upstream/master and updated config.json

bin/journey-test.sh

 
 make_local_trackler() {
   local trackler="$1"
-  echo ">>> make_local_trackler(trackler=\"${trackler}\")"
+  local xapi_home="$2"
+  echo ">>> make_local_trackler(trackler=\"${trackler}\", xapi_home=\"${xapi_home}\")"
 
   local xjava=$( pwd )
   pushd ${trackler}
   cp ${xjava}/config.json tracks/java
   cp -r ${xjava}/exercises tracks/java
 
+  # Set the version to that expected by x-api
+  version=$( grep -m 1 'trackler' ${xapi_home}/Gemfile.lock | sed 's/.*(//' | sed 's/)//' )
+  echo "module Trackler VERSION = \"${version}\" end" > lib/trackler/version.rb
+
   gem install bundler
   bundle install
   gem build trackler.gemspec
   clean "${build_dir}"
 
   # Make a version of trackler that includes the source from this repo.
+  git_clone "x-api" "${xapi_home}"
   git_clone "trackler" "${trackler_home}"
   assert_ruby_installed "${trackler_home}"
-  make_local_trackler "${trackler_home}"
+  make_local_trackler "${trackler_home}" "${xapi_home}"
 
   # Stand-up a local instance of x-api so we can fetch the exercises through it.
-  git_clone "x-api" "${xapi_home}"
   assert_ruby_installed "${xapi_home}"
   start_x_api "${xapi_home}"
 
 # Execution begins here...
 
 # If any command fails, fail the script.
-set -e
+set -ex
 SCRIPTPATH=$( pushd `dirname $0` > /dev/null && pwd && popd > /dev/null )
 EXECPATH=$( pwd )
 # Make output easier to read in CI

config.json

     "queen-attack",
     "minesweeper",
     "series",
+    "robot-simulator",
     "binary-search"
   ],
   "exercises": [
       "topics": []
     },
     {
+      "slug": "robot-simulator",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
       "slug": "binary-search",
       "difficulty": 1,
       "topics": []
-    }
+    },
   ],
   "deprecated": [
   ],

exercises/robot-simulator/build.gradle

+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

+../../main/java/GridPosition.java

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

+../../main/java/Orientation.java

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

+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

+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

+enum Orientation {
+
+    NORTH, EAST, SOUTH, WEST
+
+}

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

+final class Robot {
+
+
+
+}

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

+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

 include 'raindrops'
 include 'rna-transcription'
 include 'robot-name'
+include 'robot-simulator'
 include 'roman-numerals'
 include 'prime-factors'
 include 'scrabble-score'