Explorar el Código

Fixes #714 assertTrue -> assertEquals

Tyler Matthews hace 9 años
padre
commit
136f9af401
Se han modificado 1 ficheros con 24 adiciones y 24 borrados
  1. 24
    24
      exercises/robot-simulator/src/test/java/RobotTest.java

+ 24
- 24
exercises/robot-simulator/src/test/java/RobotTest.java Ver fichero

1
 import org.junit.Ignore;
1
 import org.junit.Ignore;
2
 import org.junit.Test;
2
 import org.junit.Test;
3
 
3
 
4
-import static org.junit.Assert.assertTrue;
4
+import static org.junit.Assert.assertEquals;
5
 
5
 
6
 public class RobotTest {
6
 public class RobotTest {
7
 
7
 
10
         final GridPosition initialGridPosition = new GridPosition(0, 0);
10
         final GridPosition initialGridPosition = new GridPosition(0, 0);
11
         final Robot robot = new Robot(initialGridPosition, Orientation.NORTH);
11
         final Robot robot = new Robot(initialGridPosition, Orientation.NORTH);
12
 
12
 
13
-        assertTrue(robot.getGridPosition().equals(initialGridPosition));
13
+		assertEquals(robot.getGridPosition(), initialGridPosition);
14
     }
14
     }
15
 
15
 
16
     @Ignore("Remove to run test")
16
     @Ignore("Remove to run test")
19
         final Orientation initialOrientation = Orientation.NORTH;
19
         final Orientation initialOrientation = Orientation.NORTH;
20
         final Robot robot = new Robot(new GridPosition(0, 0), initialOrientation);
20
         final Robot robot = new Robot(new GridPosition(0, 0), initialOrientation);
21
 
21
 
22
-        assertTrue(robot.getOrientation().equals(initialOrientation));
22
+		assertEquals(robot.getOrientation(), initialOrientation);
23
     }
23
     }
24
 
24
 
25
     @Ignore("Remove to run test")
25
     @Ignore("Remove to run test")
30
 
30
 
31
         robot.turnRight();
31
         robot.turnRight();
32
 
32
 
33
-        assertTrue(robot.getGridPosition().equals(initialGridPosition));
33
+		assertEquals(robot.getGridPosition(), initialGridPosition);
34
     }
34
     }
35
 
35
 
36
     @Ignore("Remove to run test")
36
     @Ignore("Remove to run test")
42
 
42
 
43
         final Orientation expectedOrientation = Orientation.EAST;
43
         final Orientation expectedOrientation = Orientation.EAST;
44
 
44
 
45
-        assertTrue(robot.getOrientation().equals(expectedOrientation));
45
+		assertEquals(robot.getOrientation(), expectedOrientation);
46
     }
46
     }
47
 
47
 
48
     @Ignore("Remove to run test")
48
     @Ignore("Remove to run test")
54
 
54
 
55
         final Orientation expectedOrientation = Orientation.SOUTH;
55
         final Orientation expectedOrientation = Orientation.SOUTH;
56
 
56
 
57
-        assertTrue(robot.getOrientation().equals(expectedOrientation));
57
+		assertEquals(robot.getOrientation(), expectedOrientation);
58
     }
58
     }
59
 
59
 
60
     @Ignore("Remove to run test")
60
     @Ignore("Remove to run test")
66
 
66
 
67
         final Orientation expectedOrientation = Orientation.WEST;
67
         final Orientation expectedOrientation = Orientation.WEST;
68
 
68
 
69
-        assertTrue(robot.getOrientation().equals(expectedOrientation));
69
+		assertEquals(robot.getOrientation(), expectedOrientation);
70
     }
70
     }
71
 
71
 
72
     @Ignore("Remove to run test")
72
     @Ignore("Remove to run test")
78
 
78
 
79
         final Orientation expectedOrientation = Orientation.NORTH;
79
         final Orientation expectedOrientation = Orientation.NORTH;
80
 
80
 
81
-        assertTrue(robot.getOrientation().equals(expectedOrientation));
81
+		assertEquals(robot.getOrientation(), expectedOrientation);
82
     }
82
     }
83
 
83
 
84
     @Ignore("Remove to run test")
84
     @Ignore("Remove to run test")
89
 
89
 
90
         robot.turnLeft();
90
         robot.turnLeft();
91
 
91
 
92
-        assertTrue(robot.getGridPosition().equals(initialGridPosition));
92
+		assertEquals(robot.getGridPosition(), initialGridPosition);
93
     }
93
     }
94
 
94
 
95
     @Ignore("Remove to run test")
95
     @Ignore("Remove to run test")
101
 
101
 
102
         final Orientation expectedOrientation = Orientation.WEST;
102
         final Orientation expectedOrientation = Orientation.WEST;
103
 
103
 
104
-        assertTrue(robot.getOrientation().equals(expectedOrientation));
104
+		assertEquals(robot.getOrientation(), expectedOrientation);
105
     }
105
     }
106
 
106
 
107
     @Ignore("Remove to run test")
107
     @Ignore("Remove to run test")
113
 
113
 
114
         final Orientation expectedOrientation = Orientation.SOUTH;
114
         final Orientation expectedOrientation = Orientation.SOUTH;
115
 
115
 
116
-        assertTrue(robot.getOrientation().equals(expectedOrientation));
116
+		assertEquals(robot.getOrientation(), expectedOrientation);
117
     }
117
     }
118
 
118
 
119
     @Ignore("Remove to run test")
119
     @Ignore("Remove to run test")
125
 
125
 
126
         final Orientation expectedOrientation = Orientation.EAST;
126
         final Orientation expectedOrientation = Orientation.EAST;
127
 
127
 
128
-        assertTrue(robot.getOrientation().equals(expectedOrientation));
128
+		assertEquals(robot.getOrientation(), expectedOrientation);
129
     }
129
     }
130
 
130
 
131
     @Ignore("Remove to run test")
131
     @Ignore("Remove to run test")
137
 
137
 
138
         final Orientation expectedOrientation = Orientation.NORTH;
138
         final Orientation expectedOrientation = Orientation.NORTH;
139
 
139
 
140
-        assertTrue(robot.getOrientation().equals(expectedOrientation));
140
+		assertEquals(robot.getOrientation(), expectedOrientation);
141
     }
141
     }
142
 
142
 
143
     @Ignore("Remove to run test")
143
     @Ignore("Remove to run test")
148
 
148
 
149
         robot.advance();
149
         robot.advance();
150
 
150
 
151
-        assertTrue(robot.getOrientation().equals(initialOrientation));
151
+		assertEquals(robot.getOrientation(), initialOrientation);
152
     }
152
     }
153
 
153
 
154
     @Ignore("Remove to run test")
154
     @Ignore("Remove to run test")
160
 
160
 
161
         final GridPosition expectedGridPosition = new GridPosition(0, 1);
161
         final GridPosition expectedGridPosition = new GridPosition(0, 1);
162
 
162
 
163
-        assertTrue(robot.getGridPosition().equals(expectedGridPosition));
163
+		assertEquals(robot.getGridPosition(), expectedGridPosition);
164
     }
164
     }
165
 
165
 
166
     @Ignore("Remove to run test")
166
     @Ignore("Remove to run test")
172
 
172
 
173
         final GridPosition expectedGridPosition = new GridPosition(0, -1);
173
         final GridPosition expectedGridPosition = new GridPosition(0, -1);
174
 
174
 
175
-        assertTrue(robot.getGridPosition().equals(expectedGridPosition));
175
+		assertEquals(robot.getGridPosition(), expectedGridPosition);
176
     }
176
     }
177
 
177
 
178
     @Ignore("Remove to run test")
178
     @Ignore("Remove to run test")
184
 
184
 
185
         final GridPosition expectedGridPosition = new GridPosition(1, 0);
185
         final GridPosition expectedGridPosition = new GridPosition(1, 0);
186
 
186
 
187
-        assertTrue(robot.getGridPosition().equals(expectedGridPosition));
187
+		assertEquals(robot.getGridPosition(), expectedGridPosition);
188
     }
188
     }
189
 
189
 
190
     @Ignore("Remove to run test")
190
     @Ignore("Remove to run test")
196
 
196
 
197
         final GridPosition expectedGridPosition = new GridPosition(-1, 0);
197
         final GridPosition expectedGridPosition = new GridPosition(-1, 0);
198
 
198
 
199
-        assertTrue(robot.getGridPosition().equals(expectedGridPosition));
199
+		assertEquals(robot.getGridPosition(), expectedGridPosition);
200
     }
200
     }
201
 
201
 
202
     @Ignore("Remove to run test")
202
     @Ignore("Remove to run test")
209
         final GridPosition expectedGridPosition = new GridPosition(-4, 1);
209
         final GridPosition expectedGridPosition = new GridPosition(-4, 1);
210
         final Orientation expectedOrientation = Orientation.WEST;
210
         final Orientation expectedOrientation = Orientation.WEST;
211
 
211
 
212
-        assertTrue(robot.getGridPosition().equals(expectedGridPosition));
213
-        assertTrue(robot.getOrientation().equals(expectedOrientation));
212
+		assertEquals(robot.getGridPosition(), expectedGridPosition);
213
+		assertEquals(robot.getOrientation(), expectedOrientation);
214
     }
214
     }
215
 
215
 
216
     @Ignore("Remove to run test")
216
     @Ignore("Remove to run test")
223
         final GridPosition expectedGridPosition = new GridPosition(-3, -8);
223
         final GridPosition expectedGridPosition = new GridPosition(-3, -8);
224
         final Orientation expectedOrientation = Orientation.SOUTH;
224
         final Orientation expectedOrientation = Orientation.SOUTH;
225
 
225
 
226
-        assertTrue(robot.getGridPosition().equals(expectedGridPosition));
227
-        assertTrue(robot.getOrientation().equals(expectedOrientation));
226
+		assertEquals(robot.getGridPosition(), expectedGridPosition);
227
+		assertEquals(robot.getOrientation(), expectedOrientation);
228
     }
228
     }
229
 
229
 
230
     @Ignore("Remove to run test")
230
     @Ignore("Remove to run test")
237
         final GridPosition expectedGridPosition = new GridPosition(11, 5);
237
         final GridPosition expectedGridPosition = new GridPosition(11, 5);
238
         final Orientation expectedOrientation = Orientation.NORTH;
238
         final Orientation expectedOrientation = Orientation.NORTH;
239
 
239
 
240
-        assertTrue(robot.getGridPosition().equals(expectedGridPosition));
241
-        assertTrue(robot.getOrientation().equals(expectedOrientation));
240
+		assertEquals(robot.getGridPosition(), expectedGridPosition);
241
+		assertEquals(robot.getOrientation(), expectedOrientation);
242
     }
242
     }
243
 
243
 
244
 }
244
 }