queen-attack: update tests(#1357) (#1388)

* update queen-attack tests to version 2.1.0

* remove unchecked exceptions signature

exercises/queen-attack/.meta/src/reference/java/BoardCoordinate.java

-final class BoardCoordinate {
-
-    private final int row;
-
-    private final int column;
-
-    BoardCoordinate(final int row, final int column) throws IllegalArgumentException {
-        this.row = row;
-        this.column = column;
-
-        validateInputs();
-    }
-
-    int getRow() {
-        return row;
-    }
-
-    int getColumn() {
-        return column;
-    }
-
-    private void validateInputs() throws IllegalArgumentException {
-        validateCoordinateComponent(row, "row");
-        validateCoordinateComponent(column, "column");
-    }
-
-    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/.meta/src/reference/java/Queen.java

+final class Queen {
+
+    private final int row;
+
+    private final int column;
+
+    Queen(final int row, final int column) {
+        this.row = row;
+        this.column = column;
+
+        validatePosition();
+    }
+
+    int getRow() {
+        return row;
+    }
+
+    int getColumn() {
+        return column;
+    }
+
+    private void validatePosition() {
+        validatePositionComponent(row, "row");
+        validatePositionComponent(column, "column");
+    }
+
+    private void validatePositionComponent(final int value, final String componentName) {
+
+        if (value < 0) {
+            throw new IllegalArgumentException("Queen position must have positive " + componentName + ".");
+        }
+
+        if (value > 7) {
+            throw new IllegalArgumentException("Queen position must have " + componentName + " <= 7.");
+        }
+    }
+
+}

exercises/queen-attack/.meta/src/reference/java/QueenAttackCalculator.java

 final class QueenAttackCalculator {
 
-    private final BoardCoordinate whiteQueenCoordinate;
+    private final Queen whiteQueen;
 
-    private final BoardCoordinate blackQueenCoordinate;
+    private final Queen blackQueen;
 
-    QueenAttackCalculator(final BoardCoordinate whiteQueenCoordinate, final BoardCoordinate blackQueenCoordinate)
-            throws IllegalArgumentException {
+    QueenAttackCalculator(final Queen whiteQueen, final Queen blackQueen) {
 
-        this.whiteQueenCoordinate = whiteQueenCoordinate;
-        this.blackQueenCoordinate = blackQueenCoordinate;
+        this.whiteQueen = whiteQueen;
+        this.blackQueen = blackQueen;
 
         validateInputs();
     }
         return queensShareColumn() || queensShareRow() || queensShareDiagonal();
     }
 
-    private void validateInputs() throws IllegalArgumentException {
-        if (whiteQueenCoordinate == null || blackQueenCoordinate == null) {
-            throw new IllegalArgumentException("You must supply valid board coordinates for both Queens.");
+    private void validateInputs() {
+        if (whiteQueen == null || blackQueen == null) {
+            throw new IllegalArgumentException("You must supply valid positions for both Queens.");
         }
 
         if (queensShareBoardCoordinate()) {
-            throw new IllegalArgumentException("Queens may not occupy the same board coordinate.");
+            throw new IllegalArgumentException("Queens cannot occupy the same position.");
         }
     }
 
     }
 
     private int differenceBetweenRows() {
-        return Math.abs(whiteQueenCoordinate.getRow() - blackQueenCoordinate.getRow());
+        return Math.abs(whiteQueen.getRow() - blackQueen.getRow());
     }
 
     private int differenceBetweenColumns() {
-        return Math.abs(whiteQueenCoordinate.getColumn() - blackQueenCoordinate.getColumn());
+        return Math.abs(whiteQueen.getColumn() - blackQueen.getColumn());
     }
 
 }

exercises/queen-attack/.meta/version

-2.0.0
+2.1.0

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

     public ExpectedException expectedException = ExpectedException.none();
 
     @Test
-    public void testQueensThatDoNotShareRowColumnOrDiagonalCannotAttack() {
-        final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 4), new BoardCoordinate(6, 6));
+    public void testCreateQueenWithAValidPosition() {
+        new Queen(2, 2);
+    }
 
-        assertFalse(calculator.canQueensAttackOneAnother());
+    @Ignore("Remove to run test")
+    @Test
+    public void testCreateQueenMustHavePositiveRow() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Queen position must have positive row.");
+
+        new Queen(-2, 2);
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testQueensCanAttackOnTheSameRow() {
-        final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 4), new BoardCoordinate(2, 6));
+    public void testCreateQueenMustHaveRowOnBoard() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Queen position must have row <= 7.");
 
-        assertTrue(calculator.canQueensAttackOneAnother());
+        new Queen(8, 4);
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testQueensCanAttackOnTheSameColumn() {
-        final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(4, 5), new BoardCoordinate(2, 5));
+    public void testCreateQueenMustHavePositiveColumn() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Queen position must have positive column.");
 
-        assertTrue(calculator.canQueensAttackOneAnother());
+        new Queen(2, -2);
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testQueensCanAttackOnFirstDiagonal() {
-        final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(0, 4));
+    public void testCreateQueenMustHaveColumnOnBoard() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Queen position must have column <= 7.");
 
-        assertTrue(calculator.canQueensAttackOneAnother());
+        new Queen(4, 8);
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testQueensCanAttackOnSecondDiagonal() {
+    public void testQueensCannotAttack() {
         final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(3, 1));
+                = new QueenAttackCalculator(new Queen(2, 4), new Queen(6, 6));
 
-        assertTrue(calculator.canQueensAttackOneAnother());
+        assertFalse(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testQueensCanAttackOnThirdDiagonal() {
+    public void testQueensCanAttackOnTheSameRow() {
         final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(1, 1));
+                = new QueenAttackCalculator(new Queen(2, 4), new Queen(2, 6));
 
         assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testQueensCanAttackOnFourthDiagonal() {
+    public void testQueensCanAttackOnTheSameColumn() {
         final QueenAttackCalculator calculator
-                = new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(5, 5));
+                = new QueenAttackCalculator(new Queen(4, 5), new Queen(2, 5));
 
         assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testCoordinateWithNegativeRowNotAllowed() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Coordinate must have positive row.");
+    public void testQueensCanAttackOnFirstDiagonal() {
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new Queen(2, 2), new Queen(0, 4));
 
-        new BoardCoordinate(-2, 2);
+        assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testCoordinateWithRowGreaterThan7NotAllowed() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Coordinate must have row <= 7.");
+    public void testQueensCanAttackOnSecondDiagonal() {
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new Queen(2, 2), new Queen(3, 1));
 
-        new BoardCoordinate(8, 4);
+        assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testCoordinateWithNegativeColumnNotAllowed() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Coordinate must have positive column.");
+    public void testQueensCanAttackOnThirdDiagonal() {
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new Queen(2, 2), new Queen(1, 1));
 
-        new BoardCoordinate(2, -2);
+        assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testCoordinateWithColumnGreaterThan7NotAllowed() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Coordinate must have column <= 7.");
+    public void testQueensCanAttackOnFourthDiagonal() {
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new Queen(2, 2), new Queen(5, 5));
 
-        new BoardCoordinate(4, 8);
+        assertTrue(calculator.canQueensAttackOneAnother());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void testNullCoordinateNotAllowed() {
+    public void testNullPositionsNotAllowed() {
         expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("You must supply valid board coordinates for both Queens.");
+        expectedException.expectMessage("You must supply valid positions for both Queens.");
 
-        new QueenAttackCalculator(null, new BoardCoordinate(0, 7));
+        new QueenAttackCalculator(null, new Queen(0, 7));
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testQueensMustNotOccupyTheSameSquare() {
         expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Queens may not occupy the same board coordinate.");
+        expectedException.expectMessage("Queens cannot occupy the same position.");
 
-        new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(2, 2));
+        new QueenAttackCalculator(new Queen(2, 2), new Queen(2, 2));
     }
 
 }