Преглед изворни кода

ListOpsTest : add hint to @Ignore annotations

#442
MELANY DIAZ пре 9 година
родитељ
комит
3df07a59c6
1 измењених фајлова са 19 додато и 19 уклоњено
  1. 19
    19
      exercises/list-ops/src/test/java/ListOpsTest.java

+ 19
- 19
exercises/list-ops/src/test/java/ListOpsTest.java Прегледај датотеку

29
     }
29
     }
30
 
30
 
31
     @Test
31
     @Test
32
-    @Ignore
32
+    @Ignore("Remove to run test")
33
     public void shouldReturnTheCorrectLengthOfAnNonEmptyList() {
33
     public void shouldReturnTheCorrectLengthOfAnNonEmptyList() {
34
         final List<Integer> list = Collections.unmodifiableList(
34
         final List<Integer> list = Collections.unmodifiableList(
35
                 Arrays.asList(0, 1, 2, 3, 4)
35
                 Arrays.asList(0, 1, 2, 3, 4)
41
     }
41
     }
42
 
42
 
43
     @Test
43
     @Test
44
-    @Ignore
44
+    @Ignore("Remove to run test")
45
     public void shouldReverseAnEmptyList() {
45
     public void shouldReverseAnEmptyList() {
46
         final List<Integer> actual = ListOps.reverse(EMPTY_LIST);
46
         final List<Integer> actual = ListOps.reverse(EMPTY_LIST);
47
 
47
 
50
     }
50
     }
51
 
51
 
52
     @Test
52
     @Test
53
-    @Ignore
53
+    @Ignore("Remove to run test")
54
     public void shouldReverseANonEmptyList() {
54
     public void shouldReverseANonEmptyList() {
55
         final List<Integer> list = Collections.unmodifiableList(
55
         final List<Integer> list = Collections.unmodifiableList(
56
                 Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8)
56
                 Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8)
66
     }
66
     }
67
 
67
 
68
     @Test
68
     @Test
69
-    @Ignore
69
+    @Ignore("Remove to run test")
70
     public void shouldMapAnEmptyListAndReturnAnEmptyList() {
70
     public void shouldMapAnEmptyListAndReturnAnEmptyList() {
71
         final List<Integer> actual = ListOps.map(EMPTY_LIST, x -> x + 1);
71
         final List<Integer> actual = ListOps.map(EMPTY_LIST, x -> x + 1);
72
 
72
 
75
     }
75
     }
76
 
76
 
77
     @Test
77
     @Test
78
-    @Ignore
78
+    @Ignore("Remove to run test")
79
     public void shouldMapNonEmptyList() {
79
     public void shouldMapNonEmptyList() {
80
         final List<Integer> list
80
         final List<Integer> list
81
                 = Collections.unmodifiableList(Arrays.asList(1, 3, 5, 7));
81
                 = Collections.unmodifiableList(Arrays.asList(1, 3, 5, 7));
87
     }
87
     }
88
 
88
 
89
     @Test
89
     @Test
90
-    @Ignore
90
+    @Ignore("Remove to run test")
91
     public void shouldFilterAnEmptyListanddReturnAnEmptyList() {
91
     public void shouldFilterAnEmptyListanddReturnAnEmptyList() {
92
         final List<Integer> actual = ListOps.filter(EMPTY_LIST, x -> x > 0);
92
         final List<Integer> actual = ListOps.filter(EMPTY_LIST, x -> x > 0);
93
 
93
 
96
     }
96
     }
97
 
97
 
98
     @Test
98
     @Test
99
-    @Ignore
99
+    @Ignore("Remove to run test")
100
     public void shouldFilterNonEmptyList() {
100
     public void shouldFilterNonEmptyList() {
101
         Predicate<Integer> predicate = x -> x % 2 > 0;
101
         Predicate<Integer> predicate = x -> x % 2 > 0;
102
         final List<Integer> list = Collections.unmodifiableList(
102
         final List<Integer> list = Collections.unmodifiableList(
113
     }
113
     }
114
 
114
 
115
     @Test
115
     @Test
116
-    @Ignore
116
+    @Ignore("Remove to run test")
117
     public void shouldConcatenateZeroLists() {
117
     public void shouldConcatenateZeroLists() {
118
         List<Integer> actual = ListOps.concat();
118
         List<Integer> actual = ListOps.concat();
119
 
119
 
122
     }
122
     }
123
 
123
 
124
     @Test
124
     @Test
125
-    @Ignore
125
+    @Ignore("Remove to run test")
126
     public void shouldConcatenateOneNonEmptyList() {
126
     public void shouldConcatenateOneNonEmptyList() {
127
         final List<Integer> list
127
         final List<Integer> list
128
                 = Collections.unmodifiableList(
128
                 = Collections.unmodifiableList(
137
     }
137
     }
138
 
138
 
139
     @Test
139
     @Test
140
-    @Ignore
140
+    @Ignore("Remove to run test")
141
     public void shouldConcatenateOneEmptyList() {
141
     public void shouldConcatenateOneEmptyList() {
142
         final List<Integer> actual = ListOps.concat(EMPTY_LIST);
142
         final List<Integer> actual = ListOps.concat(EMPTY_LIST);
143
 
143
 
146
     }
146
     }
147
 
147
 
148
     @Test
148
     @Test
149
-    @Ignore
149
+    @Ignore("Remove to run test")
150
     public void shouldConcatenateTwoEmptyLists() {
150
     public void shouldConcatenateTwoEmptyLists() {
151
         final List<Integer> actual = ListOps.concat(EMPTY_LIST, EMPTY_LIST);
151
         final List<Integer> actual = ListOps.concat(EMPTY_LIST, EMPTY_LIST);
152
 
152
 
155
     }
155
     }
156
 
156
 
157
     @Test
157
     @Test
158
-    @Ignore
158
+    @Ignore("Remove to run test")
159
     public void shouldConcatenateOneEmptyAndOneNonEmptyLists() {
159
     public void shouldConcatenateOneEmptyAndOneNonEmptyLists() {
160
         final List<Integer> list
160
         final List<Integer> list
161
                 = Collections.unmodifiableList(
161
                 = Collections.unmodifiableList(
171
     }
171
     }
172
 
172
 
173
     @Test
173
     @Test
174
-    @Ignore
174
+    @Ignore("Remove to run test")
175
     public void shouldConcatenateOneNonEmptyAndOneEmptyLists() {
175
     public void shouldConcatenateOneNonEmptyAndOneEmptyLists() {
176
         final List<Integer> list
176
         final List<Integer> list
177
                 = Collections.unmodifiableList(
177
                 = Collections.unmodifiableList(
187
     }
187
     }
188
 
188
 
189
     @Test
189
     @Test
190
-    @Ignore
190
+    @Ignore("Remove to run test")
191
     public void shouldConcatenateTwoListsWithSameElements() {
191
     public void shouldConcatenateTwoListsWithSameElements() {
192
         final List<Integer> list1 = Collections.unmodifiableList(
192
         final List<Integer> list1 = Collections.unmodifiableList(
193
                 Arrays.asList(0, 1, 2, 3, 4)
193
                 Arrays.asList(0, 1, 2, 3, 4)
205
     }
205
     }
206
 
206
 
207
     @Test
207
     @Test
208
-    @Ignore
208
+    @Ignore("Remove to run test")
209
     public void shouldConcatenateSeveralLists() {
209
     public void shouldConcatenateSeveralLists() {
210
         final List<Integer> list1 = Collections.unmodifiableList(
210
         final List<Integer> list1 = Collections.unmodifiableList(
211
                 Arrays.asList(0, 1, 2, 3)
211
                 Arrays.asList(0, 1, 2, 3)
232
     }
232
     }
233
 
233
 
234
     @Test
234
     @Test
235
-    @Ignore
235
+    @Ignore("Remove to run test")
236
     public void shouldReturnIdentityWhenAnEmptyListIsReduced() {
236
     public void shouldReturnIdentityWhenAnEmptyListIsReduced() {
237
         final int expected = 0;
237
         final int expected = 0;
238
         final int actual
238
         final int actual
242
     }
242
     }
243
 
243
 
244
     @Test
244
     @Test
245
-    @Ignore
245
+    @Ignore("Remove to run test")
246
     public void shouldCalculateTheSumOfANonEmptyIntegerList() {
246
     public void shouldCalculateTheSumOfANonEmptyIntegerList() {
247
         final List<Integer> list = Collections.unmodifiableList(
247
         final List<Integer> list = Collections.unmodifiableList(
248
                 Arrays.asList(0, 1, 2, 3, 4)
248
                 Arrays.asList(0, 1, 2, 3, 4)
273
             };
273
             };
274
 
274
 
275
     @Test
275
     @Test
276
-    @Ignore
276
+    @Ignore("Remove to run test")
277
     public void shouldReduceAnEmptyListAndANonEmptyListAndReturnConcatenation() {
277
     public void shouldReduceAnEmptyListAndANonEmptyListAndReturnConcatenation() {
278
         final List<Integer> list = Collections.unmodifiableList(
278
         final List<Integer> list = Collections.unmodifiableList(
279
                 Arrays.asList(0, 1, 2, 3, 4, 5)
279
                 Arrays.asList(0, 1, 2, 3, 4, 5)
292
     }
292
     }
293
 
293
 
294
     @Test
294
     @Test
295
-    @Ignore
295
+    @Ignore("Remove to run test")
296
     public void shouldReduceTwoNonEmptyListsAndReturnConcatenation() {
296
     public void shouldReduceTwoNonEmptyListsAndReturnConcatenation() {
297
         final List<Integer> listOne = Collections.unmodifiableList(
297
         final List<Integer> listOne = Collections.unmodifiableList(
298
                 Arrays.asList(0, 1, 2, 3, 4)
298
                 Arrays.asList(0, 1, 2, 3, 4)