source: josm/trunk/test/unit/org/openstreetmap/josm/gui/layer/LayerManagerTest.java@ 10278

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

GSOC core rework - LayerManager, see #12863, fix checkstyle violations (unit tests)
File size: 13.7 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.gui.layer;
3
4import static org.junit.Assert.assertEquals;
5import static org.junit.Assert.assertFalse;
6import static org.junit.Assert.assertNotNull;
7import static org.junit.Assert.assertNull;
8import static org.junit.Assert.assertSame;
9import static org.junit.Assert.assertTrue;
10import static org.junit.Assert.fail;
11
12import java.awt.Graphics2D;
13import java.util.ArrayList;
14import java.util.Arrays;
15
16import javax.swing.Action;
17import javax.swing.Icon;
18
19import org.junit.Before;
20import org.junit.Test;
21import org.openstreetmap.josm.data.Bounds;
22import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
23import org.openstreetmap.josm.gui.MapView;
24import org.openstreetmap.josm.gui.layer.LayerManager.LayerAddEvent;
25import org.openstreetmap.josm.gui.layer.LayerManager.LayerChangeListener;
26import org.openstreetmap.josm.gui.layer.LayerManager.LayerOrderChangeEvent;
27import org.openstreetmap.josm.gui.layer.LayerManager.LayerRemoveEvent;
28import org.openstreetmap.josm.gui.util.GuiHelper;
29import org.openstreetmap.josm.tools.Predicates;
30
31/**
32 * Test the {@link LayerManager} class.
33 * @author Michael Zangl
34 *
35 */
36public class LayerManagerTest {
37
38 protected static class AbstractTestLayer extends Layer {
39 protected AbstractTestLayer() {
40 super("Test Layer");
41 }
42
43 @Override
44 public void paint(Graphics2D g, MapView mv, Bounds bbox) {
45 }
46
47 @Override
48 public void visitBoundingBox(BoundingXYVisitor v) {
49 }
50
51 @Override
52 public void mergeFrom(Layer from) {
53 }
54
55 @Override
56 public boolean isMergable(Layer other) {
57 return false;
58 }
59
60 @Override
61 public String getToolTipText() {
62 return null;
63 }
64
65 @Override
66 public Action[] getMenuEntries() {
67 return null;
68 }
69
70 @Override
71 public Object getInfoComponent() {
72 return null;
73 }
74
75 @Override
76 public Icon getIcon() {
77 return null;
78 }
79
80 @Override
81 public LayerPositionStrategy getDefaultLayerPosition() {
82 return LayerPositionStrategy.afterLast(Predicates.<Layer>alwaysTrue());
83 }
84 }
85
86 protected static class AbstractTestLayer2 extends AbstractTestLayer {}
87
88 /**
89 * Intercepts the events for easier testing.
90 * @author Michael Zangl
91 *
92 */
93 protected class CapturingLayerChangeListener implements LayerChangeListener {
94 private LayerAddEvent layerAdded;
95 private LayerRemoveEvent layerRemoved;
96 private LayerOrderChangeEvent layerOrderChanged;
97
98 @Override
99 public void layerAdded(LayerAddEvent e) {
100 GuiHelper.assertCallFromEdt();
101 assertNull(layerAdded);
102 assertSame(layerManager, e.getSource());
103 layerAdded = e;
104 }
105
106 @Override
107 public void layerRemoving(LayerRemoveEvent e) {
108 GuiHelper.assertCallFromEdt();
109 assertNull(layerRemoved);
110 assertSame(layerManager, e.getSource());
111 layerRemoved = e;
112 }
113
114 @Override
115 public void layerOrderChanged(LayerOrderChangeEvent e) {
116 GuiHelper.assertCallFromEdt();
117 assertNull(layerOrderChanged);
118 assertSame(layerManager, e.getSource());
119 layerOrderChanged = e;
120 }
121
122 }
123
124 protected LayerManager layerManager;
125
126 /**
127 * Set up test layer manager.
128 */
129 @Before
130 public void setUp() {
131 layerManager = new LayerManager();
132 }
133
134 /**
135 * {@link LayerManager#addLayer(Layer)}
136 */
137 @Test
138 public void testAddLayer() {
139 Layer layer1 = new AbstractTestLayer() {
140 @Override
141 public LayerPositionStrategy getDefaultLayerPosition() {
142 return LayerPositionStrategy.IN_FRONT;
143 }
144
145 @Override
146 public boolean isBackgroundLayer() {
147 return true;
148 }
149 };
150 Layer layer2 = new AbstractTestLayer() {
151 @Override
152 public LayerPositionStrategy getDefaultLayerPosition() {
153 return LayerPositionStrategy.IN_FRONT;
154 }
155 };
156 Layer layer3 = new AbstractTestLayer() {
157 @Override
158 public LayerPositionStrategy getDefaultLayerPosition() {
159 return LayerPositionStrategy.BEFORE_FIRST_BACKGROUND_LAYER;
160 }
161 };
162
163 layerManager.addLayer(layer1);
164 assertEquals(layerManager.getLayers(), Arrays.asList(layer1));
165 layerManager.addLayer(layer2);
166 assertEquals(layerManager.getLayers(), Arrays.asList(layer2, layer1));
167 layerManager.addLayer(layer3);
168 assertEquals(layerManager.getLayers(), Arrays.asList(layer2, layer3, layer1));
169
170 // event
171 AbstractTestLayer layer4 = new AbstractTestLayer();
172 CapturingLayerChangeListener l = new CapturingLayerChangeListener();
173 layerManager.addLayerChangeListener(l);
174 layerManager.addLayer(layer4);
175
176 assertSame(layer4, l.layerAdded.getAddedLayer());
177 assertNull(l.layerRemoved);
178 assertNull(l.layerOrderChanged);
179 }
180
181 /**
182 * {@link LayerManager#addLayer(Layer)}: duplicate layers
183 */
184 @Test(expected = IllegalArgumentException.class)
185 public void testAddLayerFails() {
186 AbstractTestLayer layer1 = new AbstractTestLayer();
187 layerManager.addLayer(layer1);
188 layerManager.addLayer(layer1);
189 }
190
191 /**
192 * {@link LayerManager#addLayer(Layer)}: illegal default layer position
193 */
194 @Test(expected = IndexOutOfBoundsException.class)
195 public void testAddLayerIllegalPosition() {
196 AbstractTestLayer layer1 = new AbstractTestLayer() {
197 @Override
198 public LayerPositionStrategy getDefaultLayerPosition() {
199 return new LayerPositionStrategy() {
200 @Override
201 public int getPosition(LayerManager manager) {
202 return 42;
203 }
204 };
205 }
206 };
207 layerManager.addLayer(layer1);
208 }
209
210 /**
211 * {@link LayerManager#removeLayer(Layer)}
212 */
213 @Test
214 public void testRemoveLayer() {
215 AbstractTestLayer layer1 = new AbstractTestLayer();
216 AbstractTestLayer layer2 = new AbstractTestLayer();
217 layerManager.addLayer(layer1);
218 layerManager.addLayer(layer2);
219 assertEquals(layerManager.getLayers(), Arrays.asList(layer1, layer2));
220
221 CapturingLayerChangeListener l = new CapturingLayerChangeListener();
222 layerManager.addLayerChangeListener(l);
223 layerManager.removeLayer(layer2);
224 assertEquals(layerManager.getLayers(), Arrays.asList(layer1));
225
226 assertNull(l.layerAdded);
227 assertSame(layer2, l.layerRemoved.getRemovedLayer());
228 assertNull(l.layerOrderChanged);
229 }
230
231 /**
232 * {@link LayerManager#moveLayer(Layer, int)}
233 */
234 @Test
235 public void testMoveLayer() {
236 AbstractTestLayer layer1 = new AbstractTestLayer();
237 AbstractTestLayer layer2 = new AbstractTestLayer();
238 layerManager.addLayer(layer1);
239 layerManager.addLayer(layer2);
240 assertEquals(layerManager.getLayers(), Arrays.asList(layer1, layer2));
241
242 layerManager.moveLayer(layer2, 0);
243 assertEquals(layerManager.getLayers(), Arrays.asList(layer2, layer1));
244
245 CapturingLayerChangeListener l = new CapturingLayerChangeListener();
246 layerManager.addLayerChangeListener(l);
247 layerManager.moveLayer(layer2, 1);
248 assertEquals(layerManager.getLayers(), Arrays.asList(layer1, layer2));
249
250 assertNull(l.layerAdded);
251 assertNull(l.layerRemoved);
252 assertNotNull(l.layerOrderChanged);
253
254 // This should not change anything and not fire any event
255 layerManager.moveLayer(layer2, 1);
256 assertEquals(layerManager.getLayers(), Arrays.asList(layer1, layer2));
257 }
258
259 /**
260 * {@link LayerManager#moveLayer(Layer, int)} fails for wrong index
261 */
262 @Test(expected = IndexOutOfBoundsException.class)
263 public void testMoveLayerFailsRange() {
264 AbstractTestLayer layer1 = new AbstractTestLayer();
265 AbstractTestLayer layer2 = new AbstractTestLayer();
266 layerManager.addLayer(layer1);
267 layerManager.addLayer(layer2);
268 layerManager.moveLayer(layer2, 2);
269 }
270
271 /**
272 * {@link LayerManager#moveLayer(Layer, int)} fails for wrong layer
273 */
274 @Test(expected = IllegalArgumentException.class)
275 public void testMoveLayerFailsNotInList() {
276 AbstractTestLayer layer1 = new AbstractTestLayer();
277 AbstractTestLayer layer2 = new AbstractTestLayer();
278 layerManager.addLayer(layer1);
279 layerManager.moveLayer(layer2, 0);
280 }
281
282 /**
283 * {@link LayerManager#getLayers()} unmodifiable
284 */
285 @Test(expected = UnsupportedOperationException.class)
286 public void testGetLayers() {
287 // list should be immutable
288 AbstractTestLayer layer1 = new AbstractTestLayer();
289 AbstractTestLayer layer2 = new AbstractTestLayer();
290 layerManager.addLayer(layer1);
291 layerManager.addLayer(layer2);
292 layerManager.getLayers().remove(0);
293 }
294
295 /**
296 * {@link LayerManager#getLayersOfType(Class)}
297 */
298 @Test
299 public void testGetLayersOfType() {
300 AbstractTestLayer2 layer1 = new AbstractTestLayer2();
301 AbstractTestLayer2 layer2 = new AbstractTestLayer2();
302 layerManager.addLayer(layer1);
303 layerManager.addLayer(new AbstractTestLayer());
304 layerManager.addLayer(layer2);
305
306 assertEquals(layerManager.getLayersOfType(AbstractTestLayer2.class), Arrays.asList(layer1, layer2));
307 }
308
309 /**
310 * {@link LayerManager#containsLayer(Layer)}
311 */
312 @Test
313 public void testContainsLayer() {
314 AbstractTestLayer layer = new AbstractTestLayer();
315 layerManager.addLayer(layer);
316 layerManager.addLayer(new AbstractTestLayer());
317
318 assertTrue(layerManager.containsLayer(layer));
319 assertFalse(layerManager.containsLayer(new AbstractTestLayer()));
320 }
321
322 /**
323 * {@link LayerManager#addLayerChangeListener(LayerChangeListener)}
324 */
325 @Test
326 public void testAddLayerChangeListener() {
327 CapturingLayerChangeListener l = new CapturingLayerChangeListener();
328 layerManager.addLayerChangeListener(l);
329 assertNull(l.layerAdded);
330 assertNull(l.layerRemoved);
331 assertNull(l.layerOrderChanged);
332 }
333
334 /**
335 * {@link LayerManager#addLayerChangeListener(LayerChangeListener)} twice
336 */
337 @Test(expected = IllegalArgumentException.class)
338 public void testAddLayerChangeListenerDupplicates() {
339 CapturingLayerChangeListener l = new CapturingLayerChangeListener();
340 layerManager.addLayerChangeListener(l);
341 layerManager.addLayerChangeListener(l);
342 }
343
344 /**
345 * {@link LayerManager#addLayerChangeListener(LayerChangeListener, boolean)} fires fake add events
346 */
347 @Test
348 public void testAddLayerChangeListenerFire() {
349 final ArrayList<Layer> fired = new ArrayList<>();
350 AbstractTestLayer layer1 = new AbstractTestLayer();
351 AbstractTestLayer layer2 = new AbstractTestLayer();
352 layerManager.addLayer(layer1);
353 layerManager.addLayer(layer2);
354 layerManager.addLayerChangeListener(new LayerChangeListener() {
355 @Override
356 public void layerRemoving(LayerRemoveEvent e) {
357 fail();
358 }
359
360 @Override
361 public void layerOrderChanged(LayerOrderChangeEvent e) {
362 fail();
363 }
364
365 @Override
366 public void layerAdded(LayerAddEvent e) {
367 fired.add(e.getAddedLayer());
368 }
369 }, true);
370
371 assertEquals(Arrays.asList(layer1, layer2), fired);
372 }
373
374 /**
375 * {@link LayerManager#removeLayerChangeListener(LayerChangeListener)}
376 */
377 @Test
378 public void testRemoveLayerChangeListener() {
379 CapturingLayerChangeListener l = new CapturingLayerChangeListener();
380 layerManager.addLayerChangeListener(l);
381 layerManager.addLayer(new AbstractTestLayer());
382 layerManager.removeLayerChangeListener(l);
383 layerManager.addLayer(new AbstractTestLayer());
384 // threw exception when fired twice.
385 assertNotNull(l.layerAdded);
386 assertNull(l.layerRemoved);
387 assertNull(l.layerOrderChanged);
388 }
389
390 /**
391 * {@link LayerManager#removeLayerChangeListener(LayerChangeListener)} listener not in list
392 */
393 @Test(expected = IllegalArgumentException.class)
394 public void testRemoveLayerChangeListenerNotAdded() {
395 CapturingLayerChangeListener l = new CapturingLayerChangeListener();
396 layerManager.removeLayerChangeListener(l);
397 }
398
399 /**
400 * {@link LayerManager#removeLayerChangeListener(LayerChangeListener, boolean)} fires fake remove events
401 */
402 @Test
403 public void testRemoveLayerChangeListenerFire() {
404 final ArrayList<Layer> fired = new ArrayList<>();
405 AbstractTestLayer layer1 = new AbstractTestLayer();
406 AbstractTestLayer layer2 = new AbstractTestLayer();
407 layerManager.addLayer(layer1);
408 layerManager.addLayer(layer2);
409 LayerChangeListener listener = new LayerChangeListener() {
410 @Override
411 public void layerRemoving(LayerRemoveEvent e) {
412 fired.add(e.getRemovedLayer());
413 }
414
415 @Override
416 public void layerOrderChanged(LayerOrderChangeEvent e) {
417 fail();
418 }
419
420 @Override
421 public void layerAdded(LayerAddEvent e) {
422 fail();
423 }
424 };
425 layerManager.addLayerChangeListener(listener, false);
426 layerManager.removeLayerChangeListener(listener, true);
427
428 assertEquals(Arrays.asList(layer1, layer2), fired);
429 }
430
431}
Note: See TracBrowser for help on using the repository browser.