Refactor queen-attack to use a Coordinate type

exercises/queen-attack/src/example/java/BoardCoordinate.java

+public final class BoardCoordinate {
+
+    private final int rank;
+
+    private final int file;
+
+    public BoardCoordinate(final int rank, final int file) throws IllegalArgumentException {
+        this.rank = rank;
+        this.file = file;
+
+        validateInputs();
+    }
+
+    public int getRank() {
+        return rank;
+    }
+
+    public int getFile() {
+        return file;
+    }
+
+    private void validateInputs() throws IllegalArgumentException {
+        validateCoordinateComponent(rank, "rank");
+        validateCoordinateComponent(file, "file");
+    }
+
+    private void validateCoordinateComponent(final int value, final String componentName)
+            throws IllegalArgumentException {
+
+        if (value < 0) {
+            throw new IllegalArgumentException("Coordinate must have positive " + componentName + ".");
+        }
+
+        if (value > 7) {
+            throw new IllegalArgumentException("Coordinate must have " + componentName + " <= 7.");
+        }
+    }
+
+}

exercises/queen-attack/src/example/java/QueenAttackCalculator.java

-import java.util.Arrays;
-
 public final class QueenAttackCalculator {
 
-    private final int[] queen1Coordinates;
+    private final BoardCoordinate whiteQueenCoordinate;
 
-    private final int[] queen2Coordinates;
+    private final BoardCoordinate blackQueenCoordinate;
 
-    public QueenAttackCalculator(final int[] queen1Coordinates, final int[] queen2Coordinates)
+    public QueenAttackCalculator(final BoardCoordinate whiteQueenCoordinate, final BoardCoordinate blackQueenCoordinate)
             throws IllegalArgumentException {
 
-        this.queen1Coordinates = queen1Coordinates;
-        this.queen2Coordinates = queen2Coordinates;
+        this.whiteQueenCoordinate = whiteQueenCoordinate;
+        this.blackQueenCoordinate = blackQueenCoordinate;
 
         validateInputs();
     }
     }
 
     private void validateInputs() throws IllegalArgumentException {
-        if (queen1Coordinates == null
-                || queen2Coordinates == null
-                || queen1Coordinates.length != 2
-                || queen2Coordinates.length != 2) {
-
-            throw new IllegalArgumentException("You must supply valid 2-dimensional coordinate arrays for both Queens.");
-        }
-
-        final int[] rankCoordinates = new int[2];
-        rankCoordinates[0] = queen1Coordinates[0];
-        rankCoordinates[1] = queen2Coordinates[0];
-        Arrays.sort(rankCoordinates);
-
-        if (rankCoordinates[0] < 0) {
-            throw new IllegalArgumentException("Queens must both have positive rank.");
-        }
-
-        if (rankCoordinates[1] > 7) {
-            throw new IllegalArgumentException("Queens must both have rank <= 7.");
-        }
-
-        final int[] fileCoordinates = new int[2];
-        fileCoordinates[0] = queen1Coordinates[1];
-        fileCoordinates[1] = queen2Coordinates[1];
-        Arrays.sort(fileCoordinates);
-
-        if (fileCoordinates[0] < 0) {
-            throw new IllegalArgumentException("Queens must both have positive file.");
-        }
-
-        if (fileCoordinates[1] > 7) {
-            throw new IllegalArgumentException("Queens must both have file <= 7.");
+        if (whiteQueenCoordinate == null || blackQueenCoordinate == null) {
+            throw new IllegalArgumentException("You must supply valid board coordinates for both Queens.");
         }
 
-        if (queensShareSquare()) {
-            throw new IllegalArgumentException("Queens must not occupy the same square.");
+        if (queensShareBoardCoordinate()) {
+            throw new IllegalArgumentException("Queens may not occupy the same board coordinate.");
         }
     }
 
         return differenceBetweenFiles() == 0;
     }
 
-    private boolean queensShareSquare() {
+    private boolean queensShareBoardCoordinate() {
         return queensShareRank() && queensShareFile();
     }
 
     }
 
     private int differenceBetweenRanks() {
-        return Math.abs(queen1Coordinates[0] - queen2Coordinates[0]);
+        return Math.abs(whiteQueenCoordinate.getRank() - blackQueenCoordinate.getRank());
     }
 
     private int differenceBetweenFiles() {
-        return Math.abs(queen1Coordinates[1] - queen2Coordinates[1]);
+        return Math.abs(whiteQueenCoordinate.getFile() - blackQueenCoordinate.getFile());
     }
 
 }

exercises/queen-attack/src/main/java/Coordinate.java

+public final class Coordinate {
+
+
+
+}

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

 
     @Test
     public void testNoExceptionThrownIfBothQueenPositionsValid() {
-        new QueenAttackCalculator(new int[]{2, 2}, new int[]{0, 7});
+        new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(0, 7));
     }
 
     @Ignore
     @Test
     public void testNullInputNotAllowed() {
         expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("You must supply valid 2-dimensional coordinate arrays for both Queens.");
+        expectedException.expectMessage("You must supply valid board coordinates for both Queens.");
 
-        new QueenAttackCalculator(null, new int[]{3, 4});
+        new QueenAttackCalculator(null, new BoardCoordinate(0, 7));
     }
 
     @Ignore
     @Test
     public void testNegativeRankNotAllowed() {
         expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Queens must both have positive rank.");
+        expectedException.expectMessage("Coordinate must have positive rank.");
 
-        new QueenAttackCalculator(new int[]{-2, 2}, new int[]{2, 2});
+        new BoardCoordinate(-2, 2);
     }
 
     @Ignore
     @Test
     public void testRankGreaterThan7NotAllowed() {
         expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Queens must both have rank <= 7.");
+        expectedException.expectMessage("Coordinate must have rank <= 7.");
 
-        new QueenAttackCalculator(new int[]{8, 4}, new int[]{1, 6});
+        new BoardCoordinate(8, 4);
     }
 
     @Ignore
     @Test
     public void testNegativeFileNotAllowed() {
         expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Queens must both have positive file.");
+        expectedException.expectMessage("Coordinate must have positive file.");
 
-        new QueenAttackCalculator(new int[]{2, -2}, new int[]{5, 3});
+        new BoardCoordinate(2, -2);
     }
 
     @Ignore
     @Test
     public void testFileGreaterThan7NotAllowed() {
         expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Queens must both have file <= 7.");
+        expectedException.expectMessage("Coordinate must have file <= 7.");
 
-        new QueenAttackCalculator(new int[]{4, 8}, new int[]{7, 4});
+        new BoardCoordinate(4, 8);
     }
 
     @Ignore
     @Test
     public void testQueensMustNotOccupyTheSameSquare() {
         expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Queens must not occupy the same square.");
+        expectedException.expectMessage("Queens may not occupy the same board coordinate.");
 
-        new QueenAttackCalculator(new int[]{2, 2}, new int[]{2, 2});
+        new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(2, 2));
     }
 
     @Ignore
     @Test
     public void testQueensCanAttackOnTheSameRank() {
-        final QueenAttackCalculator calculator = new QueenAttackCalculator(new int[]{2, 4}, new int[]{2, 6});
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new BoardCoordinate(2, 4), new BoardCoordinate(2, 6));
+
         assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore
     @Test
     public void testQueensCanAttackOnTheSameFile() {
-        final QueenAttackCalculator calculator = new QueenAttackCalculator(new int[]{4, 5}, new int[]{2, 5});
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new BoardCoordinate(4, 5), new BoardCoordinate(2, 5));
+
         assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore
     @Test
     public void testQueensCanAttackOnFirstDiagonal() {
-        final QueenAttackCalculator calculator = new QueenAttackCalculator(new int[]{2, 2}, new int[]{0, 4});
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(0, 4));
+
         assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore
     @Test
     public void testQueensCanAttackOnSecondDiagonal() {
-        final QueenAttackCalculator calculator = new QueenAttackCalculator(new int[]{2, 2}, new int[]{3, 1});
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(3, 1));
+
         assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore
     @Test
     public void testQueensCanAttackOnThirdDiagonal() {
-        final QueenAttackCalculator calculator = new QueenAttackCalculator(new int[]{2, 2}, new int[]{1, 1});
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(1, 1));
+
         assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore
     @Test
     public void testQueensCanAttackOnFourthDiagonal() {
-        final QueenAttackCalculator calculator = new QueenAttackCalculator(new int[]{2, 2}, new int[]{5, 5});
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(5, 5));
+
         assertTrue(calculator.canQueensAttackOneAnother());
     }