Просмотр исходного кода

minesweeper: add hints to @Ignore annotations

morrme 9 лет назад
Родитель
Сommit
69a4f04033
1 измененных файлов: 14 добавлений и 14 удалений
  1. 14
    14
      exercises/minesweeper/src/test/java/MinesweeperBoardTest.java

+ 14
- 14
exercises/minesweeper/src/test/java/MinesweeperBoardTest.java Просмотреть файл

28
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
28
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
29
     }
29
     }
30
 
30
 
31
-    @Ignore
31
+    @Ignore("Remove to run test")
32
     @Test
32
     @Test
33
     public void testInputBoardWithOneRowAndNoColumns() {
33
     public void testInputBoardWithOneRowAndNoColumns() {
34
         final List<String> inputBoard = Collections.singletonList("");
34
         final List<String> inputBoard = Collections.singletonList("");
39
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
39
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
40
     }
40
     }
41
 
41
 
42
-    @Ignore
42
+    @Ignore("Remove to run test")
43
     @Test
43
     @Test
44
     public void testInputBoardWithNoMines() {
44
     public void testInputBoardWithNoMines() {
45
         final List<String> inputBoard = Arrays.asList(
45
         final List<String> inputBoard = Arrays.asList(
60
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
60
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
61
     }
61
     }
62
 
62
 
63
-    @Ignore
63
+    @Ignore("Remove to run test")
64
     @Test
64
     @Test
65
     public void testInputBoardWithOnlyMines() {
65
     public void testInputBoardWithOnlyMines() {
66
         final List<String> inputBoard = Arrays.asList(
66
         final List<String> inputBoard = Arrays.asList(
81
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
81
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
82
     }
82
     }
83
 
83
 
84
-    @Ignore
84
+    @Ignore("Remove to run test")
85
     @Test
85
     @Test
86
     public void testInputBoardWithSingleMineAtCenter() {
86
     public void testInputBoardWithSingleMineAtCenter() {
87
         final List<String> inputBoard = Arrays.asList(
87
         final List<String> inputBoard = Arrays.asList(
102
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
102
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
103
     }
103
     }
104
 
104
 
105
-    @Ignore
105
+    @Ignore("Remove to run test")
106
     @Test
106
     @Test
107
     public void testInputBoardWithMinesAroundPerimeter() {
107
     public void testInputBoardWithMinesAroundPerimeter() {
108
         final List<String> inputBoard = Arrays.asList(
108
         final List<String> inputBoard = Arrays.asList(
123
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
123
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
124
     }
124
     }
125
 
125
 
126
-    @Ignore
126
+    @Ignore("Remove to run test")
127
     @Test
127
     @Test
128
     public void testInputBoardWithSingleRowAndTwoMines() {
128
     public void testInputBoardWithSingleRowAndTwoMines() {
129
         final List<String> inputBoard = Collections.singletonList(
129
         final List<String> inputBoard = Collections.singletonList(
140
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
140
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
141
     }
141
     }
142
 
142
 
143
-    @Ignore
143
+    @Ignore("Remove to run test")
144
     @Test
144
     @Test
145
     public void testInputBoardWithSingleRowAndTwoMinesAtEdges() {
145
     public void testInputBoardWithSingleRowAndTwoMinesAtEdges() {
146
         final List<String> inputBoard = Collections.singletonList(
146
         final List<String> inputBoard = Collections.singletonList(
157
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
157
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
158
     }
158
     }
159
 
159
 
160
-    @Ignore
160
+    @Ignore("Remove to run test")
161
     @Test
161
     @Test
162
     public void testInputBoardWithSingleColumnAndTwoMines() {
162
     public void testInputBoardWithSingleColumnAndTwoMines() {
163
         final List<String> inputBoard = Arrays.asList(
163
         final List<String> inputBoard = Arrays.asList(
182
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
182
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
183
     }
183
     }
184
 
184
 
185
-    @Ignore
185
+    @Ignore("Remove to run test")
186
     @Test
186
     @Test
187
     public void testInputBoardWithSingleColumnAndTwoMinesAtEdges() {
187
     public void testInputBoardWithSingleColumnAndTwoMinesAtEdges() {
188
         final List<String> inputBoard = Arrays.asList(
188
         final List<String> inputBoard = Arrays.asList(
207
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
207
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
208
     }
208
     }
209
 
209
 
210
-    @Ignore
210
+    @Ignore("Remove to run test")
211
     @Test
211
     @Test
212
     public void testInputBoardWithMinesInCross() {
212
     public void testInputBoardWithMinesInCross() {
213
         final List<String> inputBoard = Arrays.asList(
213
         final List<String> inputBoard = Arrays.asList(
232
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
232
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
233
     }
233
     }
234
 
234
 
235
-    @Ignore
235
+    @Ignore("Remove to run test")
236
     @Test
236
     @Test
237
     public void testLargeInputBoard() {
237
     public void testLargeInputBoard() {
238
         final List<String> inputBoard = Arrays.asList(
238
         final List<String> inputBoard = Arrays.asList(
259
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
259
         assertEquals(expectedAnnotatedRepresentation, actualAnnotatedRepresentation);
260
     }
260
     }
261
 
261
 
262
-    @Ignore
262
+    @Ignore("Remove to run test")
263
     @Test
263
     @Test
264
     public void testNullInputBoardIsRejected() {
264
     public void testNullInputBoardIsRejected() {
265
         expectedException.expect(IllegalArgumentException.class);
265
         expectedException.expect(IllegalArgumentException.class);
268
         new MinesweeperBoard(null);
268
         new MinesweeperBoard(null);
269
     }
269
     }
270
 
270
 
271
-    @Ignore
271
+    @Ignore("Remove to run test")
272
     @Test
272
     @Test
273
     public void testInputBoardWithInvalidSymbolsIsRejected() {
273
     public void testInputBoardWithInvalidSymbolsIsRejected() {
274
         expectedException.expect(IllegalArgumentException.class);
274
         expectedException.expect(IllegalArgumentException.class);
277
         new MinesweeperBoard(Collections.singletonList(" * & "));
277
         new MinesweeperBoard(Collections.singletonList(" * & "));
278
     }
278
     }
279
 
279
 
280
-    @Ignore
280
+    @Ignore("Remove to run test")
281
     @Test
281
     @Test
282
     public void testInputBoardWithInconsistentRowLengthsIsRejected() {
282
     public void testInputBoardWithInconsistentRowLengthsIsRejected() {
283
         expectedException.expect(IllegalArgumentException.class);
283
         expectedException.expect(IllegalArgumentException.class);