source: josm/trunk/test/unit/org/openstreetmap/josm/command/AddPrimitivesCommandTest.java

Last change on this file was 19528, checked in by stoecker, 8 weeks ago

see #24637 - patch by zkir (modified a bit) - allow to handle more than one style in caching
  • Property svn:eol-style set to native
File size: 12.1 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.command;
3
4import static org.junit.jupiter.api.Assertions.assertArrayEquals;
5import static org.junit.jupiter.api.Assertions.assertEquals;
6import static org.junit.jupiter.api.Assertions.assertSame;
7import static org.junit.jupiter.api.Assertions.assertTrue;
8
9import java.util.ArrayList;
10import java.util.Arrays;
11import java.util.Collections;
12import java.util.HashSet;
13import java.util.List;
14
15import org.openstreetmap.josm.TestUtils;
16import org.openstreetmap.josm.data.coor.LatLon;
17import org.openstreetmap.josm.data.osm.DataSet;
18import org.openstreetmap.josm.data.osm.Node;
19import org.openstreetmap.josm.data.osm.NodeData;
20import org.openstreetmap.josm.data.osm.OsmPrimitive;
21import org.openstreetmap.josm.data.osm.PrimitiveData;
22import org.openstreetmap.josm.data.osm.User;
23import org.openstreetmap.josm.data.osm.Way;
24import org.openstreetmap.josm.data.osm.WayData;
25import org.openstreetmap.josm.gui.layer.OsmDataLayer;
26import org.openstreetmap.josm.gui.mappaint.ElemStyles;
27import org.openstreetmap.josm.testutils.annotations.BasicPreferences;
28import org.openstreetmap.josm.testutils.annotations.I18n;
29
30import nl.jqno.equalsverifier.EqualsVerifier;
31import nl.jqno.equalsverifier.Warning;
32import org.junit.jupiter.api.Test;
33
34/**
35 * Unit tests of {@link AddPrimitivesCommand} class.
36 */
37@I18n
38// We need prefs for nodes.
39@BasicPreferences
40class AddPrimitivesCommandTest {
41 /**
42 * Test if the add command is executed correctly and does not set the modified flag.
43 */
44 @Test
45 void testAdd() {
46 DataSet ds = new DataSet();
47
48 List<PrimitiveData> testData = createTestData();
49 assertTrue(new AddPrimitivesCommand(testData, ds).executeCommand());
50
51 testContainsTestData(ds);
52 assertEquals(3, ds.getAllSelected().size());
53 }
54
55 /**
56 * Test if the add command sets the selection.
57 */
58 @Test
59 void testAddSetSelection() {
60 DataSet ds = new DataSet();
61
62 List<PrimitiveData> testData = createTestData();
63 assertTrue(new AddPrimitivesCommand(testData, testData.subList(2, 3), ds).executeCommand());
64
65 testContainsTestData(ds);
66
67 assertEquals(1, ds.getAllSelected().size());
68 assertEquals(1, ds.getSelectedWays().size());
69 }
70
71 /**
72 * Tests if the add command respects the data set.
73 */
74 @Test
75 void testAddToLayer() {
76 DataSet ds1 = new DataSet();
77 DataSet ds2 = new DataSet();
78
79 List<PrimitiveData> testData = createTestData();
80 assertTrue(new AddPrimitivesCommand(testData, testData.subList(2, 3), ds1).executeCommand());
81
82 testContainsTestData(ds1);
83 assertTrue(ds2.allPrimitives().isEmpty());
84
85 assertEquals(1, ds1.getAllSelected().size());
86 assertEquals(1, ds1.getSelectedWays().size());
87 }
88
89 /**
90 * Tests if the add command ignores existing data
91 */
92 @Test
93 void testAddIgnoresExisting() {
94 DataSet ds = new DataSet();
95
96 List<PrimitiveData> testData = createTestData();
97 assertTrue(new AddPrimitivesCommand(testData, ds).executeCommand());
98 assertEquals(2, ds.getNodes().size());
99 assertEquals(1, ds.getWays().size());
100
101 testData.set(2, createTestNode(7));
102 assertTrue(new AddPrimitivesCommand(testData, ds).executeCommand());
103
104 assertEquals(3, ds.getNodes().size());
105 assertEquals(1, ds.getWays().size());
106 }
107
108 /**
109 * Test {@link AddPrimitivesCommand#getDescriptionText()}
110 */
111 @Test
112 void testDescription() {
113 DataSet ds = new DataSet();
114
115 List<PrimitiveData> testData = createTestData();
116 NodeData data2 = createTestNode(7);
117
118 AddPrimitivesCommand command1 = new AddPrimitivesCommand(testData, ds);
119 AddPrimitivesCommand command2 = new AddPrimitivesCommand(Collections.singletonList(data2), ds);
120
121 assertEquals("Added 3 objects", command1.getDescriptionText());
122 assertEquals("Added 1 object", command2.getDescriptionText());
123
124 // Name must be the same after execution.
125 assertTrue(command1.executeCommand());
126 assertTrue(command2.executeCommand());
127
128 assertEquals("Added 3 objects", command1.getDescriptionText());
129 assertEquals("Added 1 object", command2.getDescriptionText());
130 }
131
132 /**
133 * Test {@link AddPrimitivesCommand#undoCommand()}
134 */
135 @Test
136 void testUndo() {
137 DataSet ds = new DataSet();
138
139 List<PrimitiveData> testData = createTestData();
140
141 AddPrimitivesCommand command = new AddPrimitivesCommand(testData, ds);
142
143 assertTrue(command.executeCommand());
144
145 assertEquals(3, ds.allPrimitives().size());
146 assertEquals(1, ds.getWays().size());
147 Way way = ds.getWays().iterator().next();
148
149 for (int i = 0; i < 2; i++) {
150 // Needs to work multiple times.
151 command.undoCommand();
152
153 assertEquals(0, ds.allPrimitives().size());
154 assertEquals(0, ds.getWays().size());
155
156 // redo
157 assertTrue(command.executeCommand());
158
159 assertEquals(3, ds.allPrimitives().size());
160 assertEquals(1, ds.getWays().size());
161 assertSame(way, ds.getWays().iterator().next());
162 }
163 }
164
165 /**
166 * Tests if the undo command does not remove
167 * data ignored by by the add command because they where already existing.
168 */
169 @Test
170 void testUndoIgnoresExisting() {
171 DataSet ds = new DataSet();
172
173 List<PrimitiveData> testData = createTestData();
174
175 assertTrue(new AddPrimitivesCommand(testData, ds).executeCommand());
176 assertEquals(2, ds.getNodes().size());
177 assertEquals(1, ds.getWays().size());
178
179 testData.set(2, createTestNode(7));
180
181 AddPrimitivesCommand command = new AddPrimitivesCommand(testData, ds);
182
183 assertTrue(command.executeCommand());
184
185 for (int i = 0; i < 2; i++) {
186 // Needs to work multiple times.
187 assertEquals(3, ds.getNodes().size());
188 assertEquals(1, ds.getWays().size());
189
190 command.undoCommand();
191
192 assertEquals(2, ds.getNodes().size());
193 assertEquals(1, ds.getWays().size());
194
195 // redo
196 assertTrue(command.executeCommand());
197 }
198 }
199
200 /**
201 * Tests if the undo command does not remove
202 * data ignored by by the add command because they where already existing.
203 * Simulates regression in #14620
204 */
205 @Test
206 void testUndoIgnoresExistingAsDeleted() {
207 DataSet ds = new DataSet();
208
209 List<PrimitiveData> testData = createTestData();
210
211 assertTrue(new AddPrimitivesCommand(testData, ds).executeCommand());
212 assertEquals(2, ds.getNodes().size());
213 assertEquals(1, ds.getWays().size());
214
215 ds.getNodes().forEach(n -> n.setDeleted(true));
216
217 AddPrimitivesCommand command = new AddPrimitivesCommand(testData, ds);
218
219 assertTrue(command.executeCommand());
220
221 for (int i = 0; i < 2; i++) {
222 // Needs to work multiple times.
223 assertEquals(2, ds.getNodes().size());
224 assertEquals(1, ds.getWays().size());
225
226 command.undoCommand();
227
228 assertEquals(2, ds.getNodes().size());
229 assertEquals(1, ds.getWays().size());
230
231 // redo
232 assertTrue(command.executeCommand());
233 }
234 }
235
236 /**
237 * Tests if the undo command does not remove
238 * data ignored by by the add command because they where already existing.
239 */
240 @Test
241 void testUndoIgnoresExistingSameUniqueIdDifferentType() {
242 DataSet ds = new DataSet();
243
244 List<PrimitiveData> testData = new ArrayList<>(createTestData());
245
246 assertTrue(new AddPrimitivesCommand(testData, ds).executeCommand());
247 assertEquals(2, ds.getNodes().size());
248 assertEquals(1, ds.getWays().size());
249
250 NodeData n7Data = createTestNode(7);
251 NodeData n8Data = createTestNode(8);
252 Way w2 = new Way(5);
253 Node n7 = new Node(7);
254 n7.load(n7Data);
255 Node n8 = new Node(8);
256 n8.load(n8Data);
257 w2.setNodes(Arrays.asList(n7, n8));
258 testData.set(2, createTestNode(7));
259 testData.add(n8.save());
260 testData.add(w2.save());
261
262 AddPrimitivesCommand command = new AddPrimitivesCommand(testData, ds);
263
264 assertTrue(command.executeCommand());
265
266 for (int i = 0; i < 2; i++) {
267 assertEquals(4, ds.getNodes().size());
268 assertEquals(2, ds.getWays().size());
269
270 // Needs to work multiple times.
271 command.undoCommand();
272
273 assertEquals(2, ds.getNodes().size());
274 assertEquals(1, ds.getWays().size());
275
276 // redo
277 assertTrue(command.executeCommand());
278
279 }
280 }
281
282 /**
283 * Test {@link AddPrimitivesCommand#getParticipatingPrimitives()}
284 */
285 @Test
286 void testParticipatingPrimitives() {
287 DataSet ds = new DataSet();
288
289 List<PrimitiveData> testData = createTestData();
290 AddPrimitivesCommand command = new AddPrimitivesCommand(testData, ds);
291 assertTrue(command.executeCommand());
292
293 assertEquals(3, command.getParticipatingPrimitives().size());
294 HashSet<OsmPrimitive> should = new HashSet<>(ds.allPrimitives());
295 assertEquals(should, new HashSet<>(command.getParticipatingPrimitives()));
296
297 // needs to be the same after undo
298 command.undoCommand();
299 assertEquals(should, new HashSet<>(command.getParticipatingPrimitives()));
300 }
301
302 /**
303 * Tests {@link AddPrimitivesCommand#fillModifiedData(java.util.Collection, java.util.Collection, java.util.Collection)}
304 */
305 @Test
306 void testFillModifiedData() {
307 ArrayList<OsmPrimitive> modified = new ArrayList<>();
308 ArrayList<OsmPrimitive> deleted = new ArrayList<>();
309 ArrayList<OsmPrimitive> added = new ArrayList<>();
310
311 List<PrimitiveData> testData = createTestData();
312 new AddPrimitivesCommand(testData, new DataSet()).fillModifiedData(modified, deleted, added);
313
314 assertArrayEquals(new Object[] {}, modified.toArray());
315 assertArrayEquals(new Object[] {}, deleted.toArray());
316 assertArrayEquals(new Object[] {}, added.toArray());
317 }
318
319 private void testContainsTestData(DataSet data) {
320 assertEquals(3, data.allPrimitives().size());
321 assertEquals(2, data.getNodes().size());
322 assertEquals(1, data.getWays().size());
323 assertEquals(3, data.allModifiedPrimitives().size());
324 for (OsmPrimitive n : data.allPrimitives()) {
325 assertEquals("test", n.get("test"));
326 assertTrue(n.isModified());
327 }
328
329 for (Node n : data.getNodes()) {
330 assertEquals(LatLon.ZERO, n.getCoor());
331 }
332
333 for (Way w : data.getWays()) {
334 assertEquals(2, w.getNodes().size());
335 assertEquals(5, w.getNode(0).getId());
336 assertEquals(6, w.getNode(1).getId());
337 }
338 }
339
340 private List<PrimitiveData> createTestData() {
341 NodeData node1 = createTestNode(5);
342 NodeData node2 = createTestNode(6);
343 WayData way = new WayData(2);
344 way.put("test", "test");
345 way.setNodeIds(Arrays.asList(node1.getId(), node2.getId()));
346 return Arrays.asList(node1, node2, way);
347 }
348
349 private NodeData createTestNode(int id) {
350 NodeData node1 = new NodeData();
351 node1.setCoor(LatLon.ZERO);
352 node1.put("test", "test");
353 node1.setId(id);
354 return node1;
355 }
356
357 /**
358 * Unit test of methods {@link AddPrimitivesCommand#equals} and {@link AddPrimitivesCommand#hashCode}.
359 */
360 @Test
361 void testEqualsContract() {
362 TestUtils.assumeWorkingEqualsVerifier();
363 EqualsVerifier.forClass(AddPrimitivesCommand.class).usingGetClass()
364 .withPrefabValues(DataSet.class,
365 new DataSet(), new DataSet())
366 .withPrefabValues(User.class,
367 User.createOsmUser(1, "foo"), User.createOsmUser(2, "bar"))
368 .withPrefabValues(OsmDataLayer.class,
369 new OsmDataLayer(new DataSet(), "1", null), new OsmDataLayer(new DataSet(), "2", null))
370 .withPrefabValues(ElemStyles.class,
371 new ElemStyles(), new ElemStyles())
372 .suppress(Warning.NONFINAL_FIELDS)
373 .verify();
374 }
375}
Note: See TracBrowser for help on using the repository browser.