source: josm/trunk/test/unit/org/openstreetmap/josm/command/DeleteCommandTest.java@ 12726

Last change on this file since 12726 was 12726, checked in by Don-vip, 7 years ago

see #13036 - deprecate Command() default constructor, fix unit tests and java warnings
File size: 15.2 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.command;
3
4import static org.junit.Assert.assertArrayEquals;
5import static org.junit.Assert.assertEquals;
6import static org.junit.Assert.assertFalse;
7import static org.junit.Assert.assertTrue;
8
9import java.util.ArrayList;
10import java.util.Arrays;
11import java.util.Collection;
12import java.util.List;
13import java.util.NoSuchElementException;
14
15import org.junit.Before;
16import org.junit.Rule;
17import org.junit.Test;
18import org.openstreetmap.josm.command.CommandTest.CommandTestDataWithRelation;
19import org.openstreetmap.josm.data.osm.DataSet;
20import org.openstreetmap.josm.data.osm.Node;
21import org.openstreetmap.josm.data.osm.OsmPrimitive;
22import org.openstreetmap.josm.data.osm.Relation;
23import org.openstreetmap.josm.data.osm.User;
24import org.openstreetmap.josm.data.osm.Way;
25import org.openstreetmap.josm.data.osm.WaySegment;
26import org.openstreetmap.josm.gui.layer.OsmDataLayer;
27import org.openstreetmap.josm.testutils.JOSMTestRules;
28
29import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
30import nl.jqno.equalsverifier.EqualsVerifier;
31import nl.jqno.equalsverifier.Warning;
32
33/**
34 * Unit tests of {@link DeleteCommand} class.
35 */
36public class DeleteCommandTest {
37
38 /**
39 * We need prefs for nodes.
40 */
41 @Rule
42 @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD")
43 public JOSMTestRules test = new JOSMTestRules().preferences().i18n();
44 private CommandTestDataWithRelation testData;
45
46 /**
47 * Set up the test data.
48 */
49 @Before
50 public void createTestData() {
51 testData = new CommandTestDataWithRelation();
52 }
53
54 /**
55 * A simple deletion test with no references
56 */
57 @Test
58 public void testSimpleDelete() {
59 Node node = testData.createNode(15);
60 assertTrue(testData.layer.data.allPrimitives().contains(node));
61
62 new DeleteCommand(node).executeCommand();
63
64 assertTrue(node.isDeleted());
65 assertTrue(node.isModified());
66 assertFalse(testData.layer.data.allNonDeletedPrimitives().contains(node));
67 }
68
69 /**
70 * A delete should not delete referred objects but should should remove the reference.
71 */
72 @Test
73 public void testDeleteIgnoresReferences() {
74 assertTrue(testData.existingNode.getReferrers().contains(testData.existingRelation));
75 new DeleteCommand(testData.existingRelation).executeCommand();
76
77 assertTrue(testData.existingRelation.isDeleted());
78 assertEquals(0, testData.existingRelation.getMembersCount());
79 assertFalse(testData.existingNode.isDeleted());
80 assertFalse(testData.existingWay.isDeleted());
81 assertFalse(testData.existingNode.getReferrers().contains(testData.existingRelation));
82
83 // same for the way
84 assertTrue(testData.existingNode.getReferrers().contains(testData.existingWay));
85 new DeleteCommand(testData.existingWay).executeCommand();
86 assertEquals(0, testData.existingWay.getNodesCount());
87 assertFalse(testData.existingNode.getReferrers().contains(testData.existingWay));
88 }
89
90 /**
91 * A delete should delete all objects with references to the deleted one
92 */
93 @Test(expected = IllegalArgumentException.class)
94 public void testDeleteFailsOnDelted() {
95 new DeleteCommand(testData.existingRelation).executeCommand();
96
97 new DeleteCommand(testData.existingRelation).executeCommand();
98 }
99
100 /**
101 * A delete should delete all objects with references to the deleted one
102 */
103 @Test
104 public void testReferredDelete() {
105 DeleteCommand.deleteWithReferences(testData.layer, Arrays.asList(testData.existingNode), true).executeCommand();
106
107 assertTrue(testData.existingNode.isDeleted());
108 assertEquals(0, testData.existingWay.getNodesCount());
109 assertTrue(testData.existingWay.isDeleted());
110 }
111
112 /**
113 * Delete nodes that would be without reference afterwards.
114 */
115 @Test
116 public void testDeleteNodesInWay() {
117 testData.existingNode.removeAll();
118 // That untagged node should be deleted.
119 testData.existingNode2.removeAll();
120 DeleteCommand.delete(Arrays.asList(testData.existingWay), true, true).executeCommand();
121
122 assertTrue(testData.existingWay.isDeleted());
123 assertTrue(testData.existingNode2.isDeleted());
124 assertFalse(testData.existingNode.isDeleted());
125 assertFalse(testData.existingRelation.isDeleted());
126
127 // Same test, now with tagged nodes
128 Node node1 = testData.createNode(15);
129 Node node2 = testData.createNode(16);
130 Node node3 = testData.createNode(17);
131 Node node4 = testData.createNode(18);
132 node2.removeAll();
133 node4.removeAll();
134 Way way1 = new Way(25, 1);
135 way1.setNodes(Arrays.asList(node1, node2, node3));
136 testData.layer.data.addPrimitive(way1);
137 Way way2 = new Way(26, 1);
138 way2.setNodes(Arrays.asList(node2, node3, node4));
139 testData.layer.data.addPrimitive(way2);
140 DeleteCommand.delete(Arrays.asList(way1, way2), true, true).executeCommand();
141
142 assertTrue(way1.isDeleted());
143 assertTrue(way2.isDeleted());
144 assertFalse(node1.isDeleted());
145 assertTrue(node2.isDeleted());
146 assertFalse(node3.isDeleted());
147 assertTrue(node4.isDeleted());
148 }
149
150 /**
151 * Test that {@link DeleteCommand} checks for non-null.
152 */
153 @Test(expected = IllegalArgumentException.class)
154 public void testConsistency() {
155 new DeleteCommand(Arrays.asList(testData.existingNode, testData.existingWay, null));
156 }
157
158 /**
159 * Test that {@link DeleteCommand} checks for the dataset
160 */
161 @Test(expected = IllegalArgumentException.class)
162 public void testConsistencyDataset() {
163 testData.layer.data.removePrimitive(testData.existingNode);
164 new DeleteCommand(Arrays.asList(testData.existingNode, testData.existingWay));
165 }
166
167 /**
168 * Test that {@link DeleteCommand} checks for non-empty list
169 */
170 @Test(expected = NoSuchElementException.class)
171 public void testConsistencyNonEmpty() {
172 new DeleteCommand(Arrays.<OsmPrimitive>asList());
173 }
174
175 /**
176 * Test that {@link DeleteCommand} checks for non-null list
177 */
178 @Test(expected = NullPointerException.class)
179 public void testConsistencyNonNull() {
180 new DeleteCommand((Collection<OsmPrimitive>) null);
181 }
182
183 /**
184 * Test {@link DeleteCommand#undoCommand()}
185 */
186 @Test
187 public void testUndo() {
188 DeleteCommand command = new DeleteCommand(
189 Arrays.asList(testData.existingNode, testData.existingNode2, testData.existingWay));
190 command.executeCommand();
191
192 assertTrue(testData.existingNode.isDeleted());
193 assertTrue(testData.existingWay.isDeleted());
194
195 command.undoCommand();
196
197 assertFalse(testData.existingNode.isDeleted());
198 assertFalse(testData.existingWay.isDeleted());
199 assertEquals("existing", testData.existingNode.get("existing"));
200
201 command.executeCommand();
202
203 assertTrue(testData.existingNode.isDeleted());
204 assertTrue(testData.existingWay.isDeleted());
205 }
206
207 /**
208 * Test {@link DeleteCommand#deleteWaySegment(OsmDataLayer, org.openstreetmap.josm.data.osm.WaySegment)}
209 * Way with only 1 segment
210 */
211 @Test
212 public void testDeleteWaySegment() {
213 Way way1 = testData.createWay(100, testData.createNode(101), testData.createNode(102));
214 WaySegment ws = new WaySegment(way1, 0);
215 Command command = DeleteCommand.deleteWaySegment(testData.layer, ws);
216 command.executeCommand();
217
218 assertTrue(way1.isDeleted());
219 }
220
221 /**
222 * Test {@link DeleteCommand#deleteWaySegment(OsmDataLayer, org.openstreetmap.josm.data.osm.WaySegment)}
223 * Delete end of way
224 */
225 @Test
226 public void testDeleteWaySegmentEndOfWay() {
227 Way way = testData.createWay(200, testData.createNode(201), testData.createNode(202), testData.createNode(203),
228 testData.createNode(204));
229 WaySegment ws = new WaySegment(way, 2);
230 Command command = DeleteCommand.deleteWaySegment(testData.layer, ws);
231 command.executeCommand();
232
233 assertEquals(3, way.getNodesCount());
234 assertEquals(201, way.getNodeId(0));
235 assertEquals(202, way.getNodeId(1));
236 assertEquals(203, way.getNodeId(2));
237 }
238
239 /**
240 * Test {@link DeleteCommand#deleteWaySegment(OsmDataLayer, org.openstreetmap.josm.data.osm.WaySegment)}
241 * Delete start of way
242 */
243 @Test
244 public void testDeleteWaySegmentStartOfWay() {
245 Way way = testData.createWay(100, testData.createNode(101), testData.createNode(102), testData.createNode(103),
246 testData.createNode(104));
247 WaySegment ws = new WaySegment(way, 0);
248 Command command = DeleteCommand.deleteWaySegment(testData.layer, ws);
249 command.executeCommand();
250
251 assertEquals(3, way.getNodesCount());
252 assertEquals(102, way.getNodeId(0));
253 assertEquals(103, way.getNodeId(1));
254 assertEquals(104, way.getNodeId(2));
255 }
256
257 /**
258 * Test {@link DeleteCommand#deleteWaySegment(OsmDataLayer, org.openstreetmap.josm.data.osm.WaySegment)}
259 * Delete start of way
260 */
261 @Test
262 public void testDeleteWaySegmentSplit() {
263 Node node103 = testData.createNode(103);
264 Node node104 = testData.createNode(104);
265 Way way = testData.createWay(100, testData.createNode(101), testData.createNode(102), node103, node104);
266 WaySegment ws = new WaySegment(way, 1);
267 Command command = DeleteCommand.deleteWaySegment(testData.layer, ws);
268 command.executeCommand();
269
270 assertEquals(2, way.getNodesCount());
271 assertEquals(101, way.getNodeId(0));
272 assertEquals(102, way.getNodeId(1));
273 // there needs to be a new way
274 assertEquals(1, node104.getReferrers().size());
275 Way newWay = (Way) node104.getReferrers().get(0);
276 assertEquals(2, newWay.getNodesCount());
277 assertEquals(103, newWay.getNodeId(0));
278 assertEquals(104, newWay.getNodeId(1));
279 }
280
281 /**
282 * Test {@link DeleteCommand#deleteWaySegment(OsmDataLayer, org.openstreetmap.josm.data.osm.WaySegment)}
283 * Delete start of way
284 */
285 @Test
286 public void testDeleteWaySegmentCycle() {
287 Node n = testData.createNode(101);
288 Way way = testData.createWay(100, n, testData.createNode(102), testData.createNode(103),
289 testData.createNode(104), n);
290 WaySegment ws = new WaySegment(way, 2);
291 Command command = DeleteCommand.deleteWaySegment(testData.layer, ws);
292 command.executeCommand();
293
294 assertEquals(4, way.getNodesCount());
295 assertEquals(104, way.getNodeId(0));
296 assertEquals(101, way.getNodeId(1));
297 assertEquals(102, way.getNodeId(2));
298 assertEquals(103, way.getNodeId(3));
299 }
300
301 /**
302 * Tests {@link DeleteCommand#getChildren()}
303 */
304 @Test
305 public void testGetChildren() {
306 testData.existingNode.put("name", "xy");
307 Collection<PseudoCommand> children = new DeleteCommand(Arrays.<OsmPrimitive>asList(testData.existingNode, testData.existingNode2))
308 .getChildren();
309 assertEquals(2, children.size());
310 assertTrue(children.stream().allMatch(c -> c.getParticipatingPrimitives().size() == 1));
311 assertTrue(children.stream().anyMatch(c -> c.getParticipatingPrimitives().iterator().next() == testData.existingNode));
312 assertTrue(children.stream().anyMatch(c -> c.getParticipatingPrimitives().iterator().next() == testData.existingNode2));
313 assertTrue(children.stream().anyMatch(c -> c.getDescriptionText().matches("Deleted '.*xy.*'")));
314 }
315
316 /**
317 * Tests {@link DeleteCommand#fillModifiedData(java.util.Collection, java.util.Collection, java.util.Collection)}
318 */
319 @Test
320 public void testFillModifiedData() {
321 ArrayList<OsmPrimitive> modified = new ArrayList<>();
322 ArrayList<OsmPrimitive> deleted = new ArrayList<>();
323 ArrayList<OsmPrimitive> added = new ArrayList<>();
324 new DeleteCommand(Arrays.<OsmPrimitive>asList(testData.existingNode)).fillModifiedData(modified, deleted, added);
325 // intentionally left empty.
326 assertArrayEquals(new Object[] {}, modified.toArray());
327 assertArrayEquals(new Object[] {}, deleted.toArray());
328 assertArrayEquals(new Object[] {}, added.toArray());
329 }
330
331 /**
332 * Tests {@link DeleteCommand#getParticipatingPrimitives()}
333 */
334 @Test
335 public void testGetParticipatingPrimitives() {
336 DeleteCommand command = new DeleteCommand(Arrays.<OsmPrimitive>asList(testData.existingNode));
337 assertArrayEquals(new Object[] {testData.existingNode }, command.getParticipatingPrimitives().toArray());
338
339 DeleteCommand command2 = new DeleteCommand(
340 Arrays.<OsmPrimitive>asList(testData.existingNode, testData.existingWay));
341 assertArrayEquals(new Object[] {testData.existingNode, testData.existingWay},
342 command2.getParticipatingPrimitives().toArray());
343 }
344
345 /**
346 * Test {@link DeleteCommand#getDescriptionText()}
347 */
348 @Test
349 public void testDescription() {
350 Node node = testData.createNode(100);
351 node.put("name", "xy");
352 Way way = testData.createWay(101);
353 way.put("name", "xy");
354 Relation relation = testData.createRelation(102);
355 relation.put("name", "xy");
356
357 List<OsmPrimitive> nodeList = Arrays.<OsmPrimitive>asList(node);
358 assertTrue(new DeleteCommand(nodeList).getDescriptionText().matches("Delete node .*xy.*"));
359 List<OsmPrimitive> wayList = Arrays.<OsmPrimitive>asList(way);
360 assertTrue(new DeleteCommand(wayList).getDescriptionText().matches("Delete way .*xy.*"));
361 List<OsmPrimitive> relationList = Arrays.<OsmPrimitive>asList(relation);
362 assertTrue(new DeleteCommand(relationList).getDescriptionText().matches("Delete relation .*xy.*"));
363
364 List<OsmPrimitive> nodesList = Arrays.<OsmPrimitive>asList(node, testData.createNode(110));
365 assertTrue(new DeleteCommand(nodesList).getDescriptionText().matches("Delete 2 nodes"));
366 List<OsmPrimitive> waysList = Arrays.<OsmPrimitive>asList(way, testData.createWay(111));
367 assertTrue(new DeleteCommand(waysList).getDescriptionText().matches("Delete 2 ways"));
368 List<OsmPrimitive> relationsList = Arrays.<OsmPrimitive>asList(relation, testData.createRelation(112));
369 assertTrue(new DeleteCommand(relationsList).getDescriptionText().matches("Delete 2 relations"));
370
371 List<OsmPrimitive> mixed = Arrays.<OsmPrimitive>asList(node, way, relation);
372 assertTrue(new DeleteCommand(mixed).getDescriptionText().matches("Delete 3 objects"));
373 }
374
375 /**
376 * Unit test of methods {@link DeleteCommand#equals} and {@link DeleteCommand#hashCode}.
377 */
378 @Test
379 public void testEqualsContract() {
380 EqualsVerifier.forClass(DeleteCommand.class).usingGetClass()
381 .withPrefabValues(DataSet.class,
382 new DataSet(), new DataSet())
383 .withPrefabValues(User.class,
384 User.createOsmUser(1, "foo"), User.createOsmUser(2, "bar"))
385 .withPrefabValues(OsmDataLayer.class,
386 new OsmDataLayer(new DataSet(), "1", null), new OsmDataLayer(new DataSet(), "2", null))
387 .suppress(Warning.NONFINAL_FIELDS)
388 .verify();
389 }
390}
Note: See TracBrowser for help on using the repository browser.