tracks/java/exercises/queen-attack/src/test/java/QueenAttackCalculatorTest.java in trackler-2.2.1.127 vs tracks/java/exercises/queen-attack/src/test/java/QueenAttackCalculatorTest.java in trackler-2.2.1.128

@@ -10,121 +10,127 @@
 
     @Rule
     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));
     }
 
 }