minesweeper: update to canonical tests

exercises/minesweeper/src/example/java/MinesweeperBoard.java

 import java.util.ArrayList;
 import java.util.List;
-import java.util.Set;
-import java.util.stream.Collectors;
 
 final class MinesweeperBoard {
 
     private final int numberOfColumns;
 
     MinesweeperBoard(final List<String> rawRepresentation) {
-        validateInputBoard(rawRepresentation);
         this.rawRepresentation = rawRepresentation;
         this.numberOfRows = rawRepresentation.size();
         this.numberOfColumns = rawRepresentation.isEmpty() ? 0 : rawRepresentation.get(0).length();
     }
 
-    List<String> getAnnotatedRepresentation() throws IllegalArgumentException {
+    List<String> withNumbers() {
         final List<String> result = new ArrayList<>();
 
         for (int rowNumber = 0; rowNumber < numberOfRows; rowNumber++) {
-            result.add(getAnnotatedRow(rowNumber));
+            result.add(getRowWithNumbers(rowNumber));
         }
 
         return result;
     }
 
-    private String getAnnotatedRow(final int rowNumber) {
+    private String getRowWithNumbers(final int rowNumber) {
         String result = "";
 
         for (int columnNumber = 0; columnNumber < numberOfColumns; columnNumber++) {
-            result += getCellAnnotation(rowNumber, columnNumber);
+            result += getCellNumber(rowNumber, columnNumber);
         }
 
         return result;
     }
 
-    private char getCellAnnotation(final int rowNumber, final int columnNumber) {
+    private char getCellNumber(final int rowNumber, final int columnNumber) {
         // If (rowNumber, columnNumber) is a mine, we're done.
         if (rawRepresentation.get(rowNumber).charAt(columnNumber) == MINE_CHAR) {
             return MINE_CHAR;
         return result;
     }
 
-    private void validateInputBoard(final List<String> inputBoard) throws IllegalArgumentException {
-        validateInputBoardIsNotNull(inputBoard);
-
-        if (inputBoard.isEmpty()) {
-            return;
-        }
-
-        validateInputBoardCharacters(inputBoard);
-        validateInputBoardColumnCounts(inputBoard);
-    }
-
-    private void validateInputBoardIsNotNull(final List<String> inputBoard) throws IllegalArgumentException {
-        if (inputBoard == null) {
-            throw new IllegalArgumentException("Input board may not be null.");
-        }
-    }
-
-    private void validateInputBoardCharacters(final List<String> inputBoard) throws IllegalArgumentException {
-        final String allBoardCharacters = String.join("", inputBoard);
-
-        if (!allBoardCharacters.matches("^[ *]*$")) {
-            throw new IllegalArgumentException("Input board can only contain the characters ' ' and '*'.");
-        }
-    }
-
-    private void validateInputBoardColumnCounts(final List<String> inputBoard) throws IllegalArgumentException {
-        final Set<Integer> setOfColumnCounts = inputBoard.stream().map(String::length).collect(Collectors.toSet());
-
-        if (setOfColumnCounts.size() > 1) {
-            throw new IllegalArgumentException("Input board rows must all have the same number of columns.");
-        }
-    }
-
 }

exercises/minesweeper/src/test/java/MinesweeperBoardTest.java

 import org.junit.Ignore;
-import org.junit.Rule;
 import org.junit.Test;
-import org.junit.rules.ExpectedException;
 
 import java.util.Arrays;
 import java.util.Collections;
  */
 public class MinesweeperBoardTest {
 
-    /*
-     * 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();
-
     @Test
     public void testInputBoardWithNoRowsAndNoColumns() {
         final List<String> inputBoard = Collections.emptyList();
-        final List<String> expectedAnnotatedRepresentation = Collections.emptyList();
-        final List<String> actualAnnotatedRepresentation
-                = new MinesweeperBoard(inputBoard).getAnnotatedRepresentation();
+        final List<String> expectedNumberedBoard = Collections.emptyList();
+        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
-        assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
+        assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testInputBoardWithOneRowAndNoColumns() {
         final List<String> inputBoard = Collections.singletonList("");
-        final List<String> expectedAnnotatedRepresentation = Collections.singletonList("");
-        final List<String> actualAnnotatedRepresentation
-                = new MinesweeperBoard(inputBoard).getAnnotatedRepresentation();
+        final List<String> expectedNumberedBoard = Collections.singletonList("");
+        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
-        assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
+        assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
 
     @Ignore("Remove to run test")
                 "   "
         );
 
-        final List<String> expectedAnnotatedRepresentation = Arrays.asList(
+        final List<String> expectedNumberedBoard = Arrays.asList(
                 "   ",
                 "   ",
                 "   "
         );
 
-        final List<String> actualAnnotatedRepresentation
-                = new MinesweeperBoard(inputBoard).getAnnotatedRepresentation();
+        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
-        assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
+        assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
 
     @Ignore("Remove to run test")
                 "***"
         );
 
-        final List<String> expectedAnnotatedRepresentation = Arrays.asList(
+        final List<String> expectedNumberedBoard = Arrays.asList(
                 "***",
                 "***",
                 "***"
         );
 
-        final List<String> actualAnnotatedRepresentation
-                = new MinesweeperBoard(inputBoard).getAnnotatedRepresentation();
+        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
-        assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
+        assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
 
     @Ignore("Remove to run test")
                 "   "
         );
 
-        final List<String> expectedAnnotatedRepresentation = Arrays.asList(
+        final List<String> expectedNumberedBoard = Arrays.asList(
                 "111",
                 "1*1",
                 "111"
         );
 
-        final List<String> actualAnnotatedRepresentation
-                = new MinesweeperBoard(inputBoard).getAnnotatedRepresentation();
+        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
-        assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
+        assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
 
     @Ignore("Remove to run test")
                 "***"
         );
 
-        final List<String> expectedAnnotatedRepresentation = Arrays.asList(
+        final List<String> expectedNumberedBoard = Arrays.asList(
                 "***",
                 "*8*",
                 "***"
         );
 
-        final List<String> actualAnnotatedRepresentation
-                = new MinesweeperBoard(inputBoard).getAnnotatedRepresentation();
+        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
-        assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
+        assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
 
     @Ignore("Remove to run test")
                 " * * "
         );
 
-        final List<String> expectedAnnotatedRepresentation = Collections.singletonList(
+        final List<String> expectedNumberedBoard = Collections.singletonList(
                 "1*2*1"
         );
 
-        final List<String> actualAnnotatedRepresentation
-                = new MinesweeperBoard(inputBoard).getAnnotatedRepresentation();
+        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
-        assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
+        assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
 
     @Ignore("Remove to run test")
                 "*   *"
         );
 
-        final List<String> expectedAnnotatedRepresentation = Collections.singletonList(
+        final List<String> expectedNumberedBoard = Collections.singletonList(
                 "*1 1*"
         );
 
-        final List<String> actualAnnotatedRepresentation
-                = new MinesweeperBoard(inputBoard).getAnnotatedRepresentation();
+        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
-        assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
+        assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
 
     @Ignore("Remove to run test")
                 " "
         );
 
-        final List<String> expectedAnnotatedRepresentation = Arrays.asList(
+        final List<String> expectedNumberedBoard = Arrays.asList(
                 "1",
                 "*",
                 "2",
                 "1"
         );
 
-        final List<String> actualAnnotatedRepresentation
-                = new MinesweeperBoard(inputBoard).getAnnotatedRepresentation();
+        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
-        assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
+        assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
 
     @Ignore("Remove to run test")
                 "*"
         );
 
-        final List<String> expectedAnnotatedRepresentation = Arrays.asList(
+        final List<String> expectedNumberedBoard = Arrays.asList(
                 "*",
                 "1",
                 " ",
                 "*"
         );
 
-        final List<String> actualAnnotatedRepresentation
-                = new MinesweeperBoard(inputBoard).getAnnotatedRepresentation();
+        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
-        assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
+        assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
 
     @Ignore("Remove to run test")
                 "  *  "
         );
 
-        final List<String> expectedAnnotatedRepresentation = Arrays.asList(
+        final List<String> expectedNumberedBoard = Arrays.asList(
                 " 2*2 ",
                 "25*52",
                 "*****",
                 " 2*2 "
         );
 
-        final List<String> actualAnnotatedRepresentation
-                = new MinesweeperBoard(inputBoard).getAnnotatedRepresentation();
+        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
-        assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
+        assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
 
     @Ignore("Remove to run test")
                 "      "
         );
 
-        final List<String> expectedAnnotatedRepresentation = Arrays.asList(
+        final List<String> expectedNumberedBoard = Arrays.asList(
                 "1*22*1",
                 "12*322",
                 " 123*2",
                 "111111"
         );
 
-        final List<String> actualAnnotatedRepresentation
-                = new MinesweeperBoard(inputBoard).getAnnotatedRepresentation();
-
-        assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void testNullInputBoardIsRejected() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Input board may not be null.");
-
-        new MinesweeperBoard(null);
-    }
+        final List<String> actualNumberedBoard = new MinesweeperBoard(inputBoard).withNumbers();
 
-    @Ignore("Remove to run test")
-    @Test
-    public void testInputBoardWithInvalidSymbolsIsRejected() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Input board can only contain the characters ' ' and '*'.");
-
-        new MinesweeperBoard(Collections.singletonList(" * & "));
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void testInputBoardWithInconsistentRowLengthsIsRejected() {
-        expectedException.expect(IllegalArgumentException.class);
-        expectedException.expectMessage("Input board rows must all have the same number of columns.");
-
-        new MinesweeperBoard(Arrays.asList(
-                "*",
-                "**",
-                "* *",
-                "*  *",
-                "*   *"
-        ));
+        assertEquals(expectedNumberedBoard, actualNumberedBoard);
     }
 
 }