Merge pull request #171 from stkent/queen-attack

queen-attack: add to track

config.json

@@ -44,7 +44,8 @@
     "pascals-triangle",
     "beer-song",
     "difference-of-squares",
-    "largest-series-product"
+    "largest-series-product",
+    "queen-attack"
   ],
   "exercises": [
     {
@@ -251,6 +252,11 @@
       "slug": "largest-series-product",
       "difficulty": 1,
       "topics": []
+    },
+    {
+      "slug": "queen-attack",
+      "difficulty": 1,
+      "topics": []
     }
   ],
   "deprecated": [

exercises/queen-attack/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/queen-attack/src/example/java/BoardCoordinate.java

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,54 @@
+public final class QueenAttackCalculator {
+
+    private final BoardCoordinate whiteQueenCoordinate;
+
+    private final BoardCoordinate blackQueenCoordinate;
+
+    public QueenAttackCalculator(final BoardCoordinate whiteQueenCoordinate, final BoardCoordinate blackQueenCoordinate)
+            throws IllegalArgumentException {
+
+        this.whiteQueenCoordinate = whiteQueenCoordinate;
+        this.blackQueenCoordinate = blackQueenCoordinate;
+
+        validateInputs();
+    }
+
+    public boolean canQueensAttackOneAnother() {
+        return queensShareFile() || queensShareRank() || queensShareDiagonal();
+    }
+
+    private void validateInputs() throws IllegalArgumentException {
+        if (whiteQueenCoordinate == null || blackQueenCoordinate == null) {
+            throw new IllegalArgumentException("You must supply valid board coordinates for both Queens.");
+        }
+
+        if (queensShareBoardCoordinate()) {
+            throw new IllegalArgumentException("Queens may not occupy the same board coordinate.");
+        }
+    }
+
+    private boolean queensShareRank() {
+        return differenceBetweenRanks() == 0;
+    }
+
+    private boolean queensShareFile() {
+        return differenceBetweenFiles() == 0;
+    }
+
+    private boolean queensShareBoardCoordinate() {
+        return queensShareRank() && queensShareFile();
+    }
+
+    private boolean queensShareDiagonal() {
+        return differenceBetweenRanks() == differenceBetweenFiles();
+    }
+
+    private int differenceBetweenRanks() {
+        return Math.abs(whiteQueenCoordinate.getRank() - blackQueenCoordinate.getRank());
+    }
+
+    private int differenceBetweenFiles() {
+        return Math.abs(whiteQueenCoordinate.getFile() - blackQueenCoordinate.getFile());
+    }
+
+}

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

@@ -0,0 +1,5 @@
+public final class BoardCoordinate {
+
+
+
+}

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

@@ -0,0 +1,5 @@
+public final class QueenAttackCalculator {
+
+
+
+}

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

@@ -0,0 +1,135 @@
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public final class QueenAttackCalculatorTest {
+
+    /*
+     * See https://github.com/junit-team/junit4/wiki/Rules for information on JUnit Rules in general and
+     * ExpectedExceptions in particular.
+     */
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+
+    @Ignore
+    @Test
+    public void testCoordinateWithNegativeRankNotAllowed() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Coordinate must have positive rank.");
+
+        new BoardCoordinate(-2, 2);
+    }
+
+    @Ignore
+    @Test
+    public void testCoordinateWithRankGreaterThan7NotAllowed() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Coordinate must have rank <= 7.");
+
+        new BoardCoordinate(8, 4);
+    }
+
+    @Ignore
+    @Test
+    public void testCoordinateWithNegativeFileNotAllowed() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Coordinate must have positive file.");
+
+        new BoardCoordinate(2, -2);
+    }
+
+    @Ignore
+    @Test
+    public void testCoordinateWithFileGreaterThan7NotAllowed() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Coordinate must have file <= 7.");
+
+        new BoardCoordinate(4, 8);
+    }
+
+    @Ignore
+    @Test
+    public void testNullCoordinateNotAllowed() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("You must supply valid board coordinates for both Queens.");
+
+        new QueenAttackCalculator(null, new BoardCoordinate(0, 7));
+    }
+
+    @Ignore
+    @Test
+    public void testQueensMustNotOccupyTheSameSquare() {
+        expectedException.expect(IllegalArgumentException.class);
+        expectedException.expectMessage("Queens may not occupy the same board coordinate.");
+
+        new QueenAttackCalculator(new BoardCoordinate(2, 2), new BoardCoordinate(2, 2));
+    }
+
+    @Ignore
+    @Test
+    public void testQueensThatDoNotShareRankFileOrDiagonalCannotAttack() {
+        final QueenAttackCalculator calculator
+                = new QueenAttackCalculator(new BoardCoordinate(2, 4), new BoardCoordinate(6, 6));
+
+        assertFalse(calculator.canQueensAttackOneAnother());
+    }
+
+    @Ignore
+    @Test
+    public void testQueensCanAttackOnTheSameRank() {
+        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 BoardCoordinate(4, 5), new BoardCoordinate(2, 5));
+
+        assertTrue(calculator.canQueensAttackOneAnother());
+    }
+
+    @Ignore
+    @Test
+    public void testQueensCanAttackOnFirstDiagonal() {
+        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 BoardCoordinate(2, 2), new BoardCoordinate(3, 1));
+
+        assertTrue(calculator.canQueensAttackOneAnother());
+    }
+
+    @Ignore
+    @Test
+    public void testQueensCanAttackOnThirdDiagonal() {
+        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 BoardCoordinate(2, 2), new BoardCoordinate(5, 5));
+
+        assertTrue(calculator.canQueensAttackOneAnother());
+    }
+
+}

exercises/settings.gradle

@@ -25,6 +25,7 @@ include 'pangram'
 include 'pascals-triangle'
 include 'phone-number'
 include 'pig-latin'
+include 'queen-attack'
 include 'raindrops'
 include 'rna-transcription'
 include 'robot-name'