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

Last change on this file since 10956 was 10775, checked in by simon04, 8 years ago

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