trackler 2.2.1.151 → 2.2.1.152

data/tracks/go/exercises/bracket-push/README.md

@@ -1,7 +1,8 @@
 # Bracket Push
 
-Given a string containing brackets `[]`, braces `{}` and parentheses `()`,
-verify that all the pairs are matched and nested correctly.
+Given a string containing brackets `[]`, braces `{}`, parentheses `()`,
+or any combination thereof, verify that any and all pairs are matched
+and nested correctly.
 
 ## Running the tests
 

data/tracks/go/exercises/bracket-push/cases_test.go

@@ -1,8 +1,8 @@
 package brackets
 
 // Source: exercism/problem-specifications
-// Commit: 5c16d05 bracket-push: Apply new "input" policy
-// Problem Specifications Version: 1.2.0
+// Commit: 9027186 bracket-push: Add test case "partially paired brackets" (#1219)
+// Problem Specifications Version: 1.3.0
 
 type bracketTest struct {
 	input    string
@@ -40,6 +40,11 @@ var testCases = []bracketTest{
 		"{ }",
 		true,
 	},
+	{
+		// partially paired brackets
+		"{[])",
+		false,
+	},
 	{
 		// simple nested brackets
 		"{[]}",

data/tracks/go/exercises/isbn-verifier/cases_test.go

@@ -1,8 +1,8 @@
 package isbn
 
 // Source: exercism/problem-specifications
-// Commit: 4288ee0 isbn-verifier: add empty isbn case
-// Problem Specifications Version: 2.2.0
+// Commit: adb99f7 isbn-verifier: Add test case with only 9 digits (#1221)
+// Problem Specifications Version: 2.4.0
 
 var testCases = []struct {
 	isbn        string
@@ -13,7 +13,7 @@ var testCases = []struct {
 	{"3-598-21508-9", false, "invalid isbn check digit"},
 	{"3-598-21507-X", true, "valid isbn number with a check digit of 10"},
 	{"3-598-21507-A", false, "check digit is a character other than X"},
-	{"3-598-2K507-0", false, "invalid character in isbn"},
+	{"3-598-P1581-X", false, "invalid character in isbn"},
 	{"3-598-2X507-9", false, "X is only valid as a check digit"},
 	{"3598215088", true, "valid isbn without separating dashes"},
 	{"359821507X", true, "isbn without separating dashes and X as check digit"},
@@ -23,4 +23,5 @@ var testCases = []struct {
 	{"3-598-21507-XX", false, "too long isbn"},
 	{"3-598-21515-X", false, "check digit of X should not be used for 0"},
 	{"", false, "empty isbn"},
+	{"134456729", false, "input is 9 characters"},
 }

data/tracks/go/exercises/yacht/cases_test.go

@@ -1,8 +1,8 @@
 package yacht
 
 // Source: exercism/problem-specifications
-// Commit: ea4689d yacht: create problem specification for scoring a single hand of yacht. (#1207)
-// Problem Specifications Version: 1.0.0
+// Commit: 6eb19d2 yacht: Add "Four of a kind is not a full house" test case (#1232)
+// Problem Specifications Version: 1.1.0
 
 var testCases = []struct {
 	description string
@@ -88,6 +88,12 @@ var testCases = []struct {
 		category:    "full house",
 		expected:    0,
 	},
+	{
+		description: "Four of a kind is not a full house",
+		dice:        []int{1, 4, 4, 4, 4},
+		category:    "full house",
+		expected:    0,
+	},
 	{
 		description: "Yacht is not a full house",
 		dice:        []int{2, 2, 2, 2, 2},

data/tracks/java/exercises/armstrong-numbers/README.md

@@ -5,7 +5,7 @@ An [Armstrong number](https://en.wikipedia.org/wiki/Narcissistic_number) is a nu
 For example:
 
 - 9 is an Armstrong number, because `9 = 9^1 = 9`
-- 10 is *not* an Armstrong number, because `10 != 1^2 + 0^2 = 2`
+- 10 is *not* an Armstrong number, because `10 != 1^2 + 0^2 = 1`
 - 153 is an Armstrong number, because: `153 = 1^3 + 5^3 + 3^3 = 1 + 125 + 27 = 153`
 - 154 is *not* an Armstrong number, because: `154 != 1^3 + 5^3 + 4^3 = 1 + 125 + 64 = 190`
 

data/tracks/java/exercises/binary-search-tree/src/test/java/BinarySearchTreeTest.java

@@ -13,13 +13,13 @@ public class BinarySearchTreeTest {
     public void dataIsRetained() {
         BinarySearchTree<Integer> binarySearchTree = new BinarySearchTree<>();
 
-        final int expected = 4;
+        int expected = 4;
         binarySearchTree.insert(expected);
 
-        final BinarySearchTree.Node<Integer> root = binarySearchTree.getRoot();
+        BinarySearchTree.Node<Integer> root = binarySearchTree.getRoot();
         assertNotNull(root);
 
-        final int actual = root.getData();
+        int actual = root.getData();
         assertEquals(expected, actual);
     }
 
@@ -27,19 +27,19 @@ public class BinarySearchTreeTest {
     @Test
     public void insertsLess() {
         BinarySearchTree<Character> binarySearchTree = new BinarySearchTree<>();
-        final char expectedRoot = '4';
-        final char expectedLeft = '2';
+        char expectedRoot = '4';
+        char expectedLeft = '2';
 
         binarySearchTree.insert(expectedRoot);
         binarySearchTree.insert(expectedLeft);
 
-        final BinarySearchTree.Node<Character> root = binarySearchTree.getRoot();
+        BinarySearchTree.Node<Character> root = binarySearchTree.getRoot();
         assertNotNull(root);
-        final BinarySearchTree.Node<Character> left = root.getLeft();
+        BinarySearchTree.Node<Character> left = root.getLeft();
         assertNotNull(left);
 
-        final char actualRoot = root.getData();
-        final char actualLeft = left.getData();
+        char actualRoot = root.getData();
+        char actualLeft = left.getData();
         assertEquals(expectedLeft, actualLeft);
         assertEquals(expectedRoot, actualRoot);
     }
@@ -48,19 +48,19 @@ public class BinarySearchTreeTest {
     @Test
     public void insertsSame() {
         BinarySearchTree<String> binarySearchTree = new BinarySearchTree<>();
-        final String expectedRoot = "4";
-        final String expectedLeft = "4";
+        String expectedRoot = "4";
+        String expectedLeft = "4";
 
         binarySearchTree.insert(expectedRoot);
         binarySearchTree.insert(expectedLeft);
 
-        final BinarySearchTree.Node<String> root = binarySearchTree.getRoot();
+        BinarySearchTree.Node<String> root = binarySearchTree.getRoot();
         assertNotNull(root);
-        final BinarySearchTree.Node<String> left = root.getLeft();
+        BinarySearchTree.Node<String> left = root.getLeft();
         assertNotNull(left);
 
-        final String actualRoot = root.getData();
-        final String actualLeft = left.getData();
+        String actualRoot = root.getData();
+        String actualLeft = left.getData();
         assertEquals(expectedLeft, actualLeft);
         assertEquals(expectedRoot, actualRoot);
     }
@@ -69,19 +69,19 @@ public class BinarySearchTreeTest {
     @Test
     public void insertsRight() {
         BinarySearchTree<Integer> binarySearchTree = new BinarySearchTree<>();
-        final int expectedRoot = 4;
-        final int expectedRight = 5;
+        int expectedRoot = 4;
+        int expectedRight = 5;
 
         binarySearchTree.insert(expectedRoot);
         binarySearchTree.insert(expectedRight);
 
-        final BinarySearchTree.Node<Integer> root = binarySearchTree.getRoot();
+        BinarySearchTree.Node<Integer> root = binarySearchTree.getRoot();
         assertNotNull(root);
-        final BinarySearchTree.Node<Integer> right = root.getRight();
+        BinarySearchTree.Node<Integer> right = root.getRight();
         assertNotNull(right);
 
-        final int actualRoot = root.getData();
-        final int actualRight = right.getData();
+        int actualRoot = root.getData();
+        int actualRight = right.getData();
         assertEquals(expectedRight, actualRight);
         assertEquals(expectedRoot, actualRoot);
     }
@@ -131,7 +131,7 @@ public class BinarySearchTreeTest {
         List<Integer> actual = binarySearchTree.getAsSortedList();
         assertEquals(expected, actual);
     }
-    
+
     @Ignore("Remove to run test")
     @Test
     public void sortsCollectionOfTwoIfSecondNumberisSameAsFirst() {

data/tracks/java/exercises/bracket-push/README.md

@@ -1,7 +1,8 @@
 # Bracket Push
 
-Given a string containing brackets `[]`, braces `{}` and parentheses `()`,
-verify that all the pairs are matched and nested correctly.
+Given a string containing brackets `[]`, braces `{}`, parentheses `()`,
+or any combination thereof, verify that any and all pairs are matched
+and nested correctly.
 
 # Java Tips
 

data/tracks/java/exercises/crypto-square/README.md

@@ -12,11 +12,15 @@ regarded as forming a rectangle when printed with intervening newlines.
 
 For example, the sentence
 
-> If man was meant to stay on the ground, god would have given us roots.
+```text
+"If man was meant to stay on the ground, god would have given us roots."
+```
 
 is normalized to:
 
-> ifmanwasmeanttostayonthegroundgodwouldhavegivenusroots
+```text
+"ifmanwasmeanttostayonthegroundgodwouldhavegivenusroots"
+```
 
 The plaintext should be organized in to a rectangle.  The size of the
 rectangle (`r x c`) should be decided by the length of the message,
@@ -27,13 +31,13 @@ Our normalized text is 54 characters long, dictating a rectangle with
 `c = 8` and `r = 7`:
 
 ```text
-ifmanwas
-meanttos
-tayonthe
-groundgo
-dwouldha
-vegivenu
-sroots
+"ifmanwas"
+"meanttos"
+"tayonthe"
+"groundgo"
+"dwouldha"
+"vegivenu"
+"sroots  "
 ```
 
 The coded message is obtained by reading down the columns going left to
@@ -42,7 +46,7 @@ right.
 The message above is coded as:
 
 ```text
-imtgdvsfearwermayoogoanouuiontnnlvtwttddesaohghnsseoau
+"imtgdvsfearwermayoogoanouuiontnnlvtwttddesaohghnsseoau"
 ```
 
 Output the encoded text in chunks that fill perfect rectangles `(r X c)`,
@@ -51,21 +55,21 @@ with `c` chunks of `r` length, separated by spaces. For phrases that are
 chunks with a single trailing space.
 
 ```text
-imtgdvs fearwer mayoogo anouuio ntnnlvt wttddes aohghn  sseoau 
+"imtgdvs fearwer mayoogo anouuio ntnnlvt wttddes aohghn  sseoau "
 ```
 
 Notice that were we to stack these, we could visually decode the
 cyphertext back in to the original message:
 
 ```text
-imtgdvs
-fearwer
-mayoogo
-anouuio
-ntnnlvt
-wttddes
-aohghn
-sseoau
+"imtgdvs"
+"fearwer"
+"mayoogo"
+"anouuio"
+"ntnnlvt"
+"wttddes"
+"aohghn "
+"sseoau "
 ```
 
 # Running the tests

data/tracks/java/exercises/grade-school/src/test/java/SchoolTest.java

@@ -38,7 +38,7 @@ public class SchoolTest {
   @Ignore("Remove to run test")
   @Test
   public void addsMoreStudentsInSameGrade() {
-    final int grade = 2;
+    int grade = 2;
     school.add("James", grade);
     school.add("Blair", grade);
     school.add("Paul", grade);

data/tracks/java/exercises/queen-attack/src/test/java/QueenAttackCalculatorTest.java

@@ -55,7 +55,7 @@ public class QueenAttackCalculatorTest {
     @Ignore("Remove to run test")
     @Test
     public void testQueensCannotAttack() {
-        final QueenAttackCalculator calculator
+        QueenAttackCalculator calculator
                 = new QueenAttackCalculator(new Queen(2, 4), new Queen(6, 6));
 
         assertFalse(calculator.canQueensAttackOneAnother());
@@ -64,7 +64,7 @@ public class QueenAttackCalculatorTest {
     @Ignore("Remove to run test")
     @Test
     public void testQueensCanAttackOnTheSameRow() {
-        final QueenAttackCalculator calculator
+        QueenAttackCalculator calculator
                 = new QueenAttackCalculator(new Queen(2, 4), new Queen(2, 6));
 
         assertTrue(calculator.canQueensAttackOneAnother());
@@ -73,7 +73,7 @@ public class QueenAttackCalculatorTest {
     @Ignore("Remove to run test")
     @Test
     public void testQueensCanAttackOnTheSameColumn() {
-        final QueenAttackCalculator calculator
+        QueenAttackCalculator calculator
                 = new QueenAttackCalculator(new Queen(4, 5), new Queen(2, 5));
 
         assertTrue(calculator.canQueensAttackOneAnother());
@@ -82,7 +82,7 @@ public class QueenAttackCalculatorTest {
     @Ignore("Remove to run test")
     @Test
     public void testQueensCanAttackOnFirstDiagonal() {
-        final QueenAttackCalculator calculator
+        QueenAttackCalculator calculator
                 = new QueenAttackCalculator(new Queen(2, 2), new Queen(0, 4));
 
         assertTrue(calculator.canQueensAttackOneAnother());
@@ -91,7 +91,7 @@ public class QueenAttackCalculatorTest {
     @Ignore("Remove to run test")
     @Test
     public void testQueensCanAttackOnSecondDiagonal() {
-        final QueenAttackCalculator calculator
+        QueenAttackCalculator calculator
                 = new QueenAttackCalculator(new Queen(2, 2), new Queen(3, 1));
 
         assertTrue(calculator.canQueensAttackOneAnother());
@@ -100,7 +100,7 @@ public class QueenAttackCalculatorTest {
     @Ignore("Remove to run test")
     @Test
     public void testQueensCanAttackOnThirdDiagonal() {
-        final QueenAttackCalculator calculator
+        QueenAttackCalculator calculator
                 = new QueenAttackCalculator(new Queen(2, 2), new Queen(1, 1));
 
         assertTrue(calculator.canQueensAttackOneAnother());
@@ -109,7 +109,7 @@ public class QueenAttackCalculatorTest {
     @Ignore("Remove to run test")
     @Test
     public void testQueensCanAttackOnFourthDiagonal() {
-        final QueenAttackCalculator calculator
+        QueenAttackCalculator calculator
                 = new QueenAttackCalculator(new Queen(2, 2), new Queen(5, 5));
 
         assertTrue(calculator.canQueensAttackOneAnother());

data/tracks/java/exercises/rail-fence-cipher/.meta/version

@@ -0,0 +1 @@
+1.1.0

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

@@ -7,9 +7,9 @@ public class RobotTest {
 
     @Test
     public void robotIsCreatedWithInitialPositionAndOrientation() {
-        final Orientation initialOrientation = Orientation.NORTH;
-        final GridPosition initialGridPosition = new GridPosition(0, 0);
-        final Robot robot = new Robot(initialGridPosition, initialOrientation);
+        Orientation initialOrientation = Orientation.NORTH;
+        GridPosition initialGridPosition = new GridPosition(0, 0);
+        Robot robot = new Robot(initialGridPosition, initialOrientation);
 
         assertEquals(robot.getOrientation(), initialOrientation);
         assertEquals(robot.getGridPosition(), initialGridPosition);
@@ -18,9 +18,9 @@ public class RobotTest {
     @Ignore("Remove to run test")
     @Test
     public void testNegativePositionsAreAllowed() {
-        final GridPosition initialGridPosition = new GridPosition(-1, -1);
-        final Orientation initialOrientation = Orientation.SOUTH;
-        final Robot robot = new Robot(initialGridPosition, initialOrientation);
+        GridPosition initialGridPosition = new GridPosition(-1, -1);
+        Orientation initialOrientation = Orientation.SOUTH;
+        Robot robot = new Robot(initialGridPosition, initialOrientation);
 
         assertEquals(robot.getOrientation(), initialOrientation);
         assertEquals(robot.getGridPosition(), initialGridPosition);
@@ -29,8 +29,8 @@ public class RobotTest {
     @Ignore("Remove to run test")
     @Test
     public void testTurningRightDoesNotChangePosition() {
-        final GridPosition initialGridPosition = new GridPosition(0, 0);
-        final Robot robot = new Robot(initialGridPosition, Orientation.NORTH);
+        GridPosition initialGridPosition = new GridPosition(0, 0);
+        Robot robot = new Robot(initialGridPosition, Orientation.NORTH);
 
         robot.turnRight();
 
@@ -40,11 +40,11 @@ public class RobotTest {
     @Ignore("Remove to run test")
     @Test
     public void testTurningRightCorrectlyChangesOrientationFromNorthToEast() {
-        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.NORTH);
+        Robot robot = new Robot(new GridPosition(0, 0), Orientation.NORTH);
 
         robot.turnRight();
 
-        final Orientation expectedOrientation = Orientation.EAST;
+        Orientation expectedOrientation = Orientation.EAST;
 
         assertEquals(robot.getOrientation(), expectedOrientation);
     }
@@ -52,11 +52,11 @@ public class RobotTest {
     @Ignore("Remove to run test")
     @Test
     public void testTurningRightCorrectlyChangesOrientationFromEastToSouth() {
-        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.EAST);
+        Robot robot = new Robot(new GridPosition(0, 0), Orientation.EAST);
 
         robot.turnRight();
 
-        final Orientation expectedOrientation = Orientation.SOUTH;
+        Orientation expectedOrientation = Orientation.SOUTH;
 
         assertEquals(robot.getOrientation(), expectedOrientation);
     }
@@ -64,11 +64,11 @@ public class RobotTest {
     @Ignore("Remove to run test")
     @Test
     public void testTurningRightCorrectlyChangesOrientationFromSouthToWest() {
-        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.SOUTH);
+        Robot robot = new Robot(new GridPosition(0, 0), Orientation.SOUTH);
 
         robot.turnRight();
 
-        final Orientation expectedOrientation = Orientation.WEST;
+        Orientation expectedOrientation = Orientation.WEST;
 
         assertEquals(robot.getOrientation(), expectedOrientation);
     }
@@ -76,11 +76,11 @@ public class RobotTest {
     @Ignore("Remove to run test")
     @Test
     public void testTurningRightCorrectlyChangesOrientationFromWestToNorth() {
-        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.WEST);
+        Robot robot = new Robot(new GridPosition(0, 0), Orientation.WEST);
 
         robot.turnRight();
 
-        final Orientation expectedOrientation = Orientation.NORTH;
+        Orientation expectedOrientation = Orientation.NORTH;
 
         assertEquals(robot.getOrientation(), expectedOrientation);
     }
@@ -88,8 +88,8 @@ public class RobotTest {
     @Ignore("Remove to run test")
     @Test
     public void testTurningLeftDoesNotChangePosition() {
-        final GridPosition initialGridPosition = new GridPosition(0, 0);
-        final Robot robot = new Robot(initialGridPosition, Orientation.NORTH);
+        GridPosition initialGridPosition = new GridPosition(0, 0);
+        Robot robot = new Robot(initialGridPosition, Orientation.NORTH);
 
         robot.turnLeft();
 
@@ -99,11 +99,11 @@ public class RobotTest {
     @Ignore("Remove to run test")
     @Test
     public void testTurningLeftCorrectlyChangesOrientationFromNorthToWest() {
-        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.NORTH);
+        Robot robot = new Robot(new GridPosition(0, 0), Orientation.NORTH);
 
         robot.turnLeft();
 
-        final Orientation expectedOrientation = Orientation.WEST;
+        Orientation expectedOrientation = Orientation.WEST;
 
         assertEquals(robot.getOrientation(), expectedOrientation);
     }
@@ -111,11 +111,11 @@ public class RobotTest {
     @Ignore("Remove to run test")
     @Test
     public void testTurningLeftCorrectlyChangesOrientationFromWestToSouth() {
-        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.WEST);
+        Robot robot = new Robot(new GridPosition(0, 0), Orientation.WEST);
 
         robot.turnLeft();
 
-        final Orientation expectedOrientation = Orientation.SOUTH;
+        Orientation expectedOrientation = Orientation.SOUTH;
 
         assertEquals(robot.getOrientation(), expectedOrientation);
     }
@@ -123,11 +123,11 @@ public class RobotTest {
     @Ignore("Remove to run test")
     @Test
     public void testTurningLeftCorrectlyChangesOrientationFromSouthToEast() {
-        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.SOUTH);
+        Robot robot = new Robot(new GridPosition(0, 0), Orientation.SOUTH);
 
         robot.turnLeft();
 
-        final Orientation expectedOrientation = Orientation.EAST;
+        Orientation expectedOrientation = Orientation.EAST;
 
         assertEquals(robot.getOrientation(), expectedOrientation);
     }
@@ -135,11 +135,11 @@ public class RobotTest {
     @Ignore("Remove to run test")
     @Test
     public void testTurningLeftCorrectlyChangesOrientationFromEastToNorth() {
-        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.EAST);
+        Robot robot = new Robot(new GridPosition(0, 0), Orientation.EAST);
 
         robot.turnLeft();
 
-        final Orientation expectedOrientation = Orientation.NORTH;
+        Orientation expectedOrientation = Orientation.NORTH;
 
         assertEquals(robot.getOrientation(), expectedOrientation);
     }
@@ -147,8 +147,8 @@ public class RobotTest {
     @Ignore("Remove to run test")
     @Test
     public void testAdvancingDoesNotChangeOrientation() {
-        final Orientation initialOrientation = Orientation.NORTH;
-        final Robot robot = new Robot(new GridPosition(0, 0), initialOrientation);
+        Orientation initialOrientation = Orientation.NORTH;
+        Robot robot = new Robot(new GridPosition(0, 0), initialOrientation);
 
         robot.advance();
 
@@ -158,11 +158,11 @@ public class RobotTest {
     @Ignore("Remove to run test")
     @Test
     public void testAdvancingWhenFacingNorthIncreasesYCoordinateByOne() {
-        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.NORTH);
+        Robot robot = new Robot(new GridPosition(0, 0), Orientation.NORTH);
 
         robot.advance();
 
-        final GridPosition expectedGridPosition = new GridPosition(0, 1);
+        GridPosition expectedGridPosition = new GridPosition(0, 1);
 
         assertEquals(robot.getGridPosition(), expectedGridPosition);
     }
@@ -170,11 +170,11 @@ public class RobotTest {
     @Ignore("Remove to run test")
     @Test
     public void testAdvancingWhenFacingSouthDecreasesYCoordinateByOne() {
-        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.SOUTH);
+        Robot robot = new Robot(new GridPosition(0, 0), Orientation.SOUTH);
 
         robot.advance();
 
-        final GridPosition expectedGridPosition = new GridPosition(0, -1);
+        GridPosition expectedGridPosition = new GridPosition(0, -1);
 
         assertEquals(robot.getGridPosition(), expectedGridPosition);
     }
@@ -182,11 +182,11 @@ public class RobotTest {
     @Ignore("Remove to run test")
     @Test
     public void testAdvancingWhenFacingEastIncreasesXCoordinateByOne() {
-        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.EAST);
+        Robot robot = new Robot(new GridPosition(0, 0), Orientation.EAST);
 
         robot.advance();
 
-        final GridPosition expectedGridPosition = new GridPosition(1, 0);
+        GridPosition expectedGridPosition = new GridPosition(1, 0);
 
         assertEquals(robot.getGridPosition(), expectedGridPosition);
     }
@@ -194,11 +194,11 @@ public class RobotTest {
     @Ignore("Remove to run test")
     @Test
     public void testAdvancingWhenFacingWestDecreasesXCoordinateByOne() {
-        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.WEST);
+        Robot robot = new Robot(new GridPosition(0, 0), Orientation.WEST);
 
         robot.advance();
 
-        final GridPosition expectedGridPosition = new GridPosition(-1, 0);
+        GridPosition expectedGridPosition = new GridPosition(-1, 0);
 
         assertEquals(robot.getGridPosition(), expectedGridPosition);
     }
@@ -206,12 +206,12 @@ public class RobotTest {
     @Ignore("Remove to run test")
     @Test
     public void testInstructionsToMoveWestAndNorth() {
-        final Robot robot = new Robot(new GridPosition(0, 0), Orientation.NORTH);
+        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;
+        GridPosition expectedGridPosition = new GridPosition(-4, 1);
+        Orientation expectedOrientation = Orientation.WEST;
 
         assertEquals(robot.getGridPosition(), expectedGridPosition);
         assertEquals(robot.getOrientation(), expectedOrientation);
@@ -220,12 +220,12 @@ public class RobotTest {
     @Ignore("Remove to run test")
     @Test
     public void testInstructionsToMoveWestAndSouth() {
-        final Robot robot = new Robot(new GridPosition(2, -7), Orientation.EAST);
+        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;
+        GridPosition expectedGridPosition = new GridPosition(-3, -8);
+        Orientation expectedOrientation = Orientation.SOUTH;
 
         assertEquals(robot.getGridPosition(), expectedGridPosition);
         assertEquals(robot.getOrientation(), expectedOrientation);
@@ -234,12 +234,12 @@ public class RobotTest {
     @Ignore("Remove to run test")
     @Test
     public void testInstructionsToMoveEastAndNorth() {
-        final Robot robot = new Robot(new GridPosition(8, 4), Orientation.SOUTH);
+        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;
+        GridPosition expectedGridPosition = new GridPosition(11, 5);
+        Orientation expectedOrientation = Orientation.NORTH;
 
         assertEquals(robot.getGridPosition(), expectedGridPosition);
         assertEquals(robot.getOrientation(), expectedOrientation);