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

Last change on this file since 11241 was 11000, checked in by michael2402, 8 years ago

Add layer manager test for resetState() and scheduleRemoval()
File size: 16.7 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.gui.layer;
3
4import static org.hamcrest.CoreMatchers.any;
5import static org.junit.Assert.assertEquals;
6import static org.junit.Assert.assertFalse;
7import static org.junit.Assert.assertNotNull;
8import static org.junit.Assert.assertNull;
9import static org.junit.Assert.assertSame;
10import static org.junit.Assert.assertTrue;
11import static org.junit.Assert.fail;
12
13import java.awt.Component;
14import java.awt.Graphics;
15import java.awt.Graphics2D;
16import java.lang.reflect.InvocationTargetException;
17import java.util.ArrayList;
18import java.util.Arrays;
19import java.util.Collections;
20
21import javax.swing.Action;
22import javax.swing.Icon;
23
24import org.junit.Before;
25import org.junit.Rule;
26import org.junit.Test;
27import org.openstreetmap.josm.data.Bounds;
28import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
29import org.openstreetmap.josm.gui.MapView;
30import org.openstreetmap.josm.gui.layer.LayerManager.LayerAddEvent;
31import org.openstreetmap.josm.gui.layer.LayerManager.LayerChangeListener;
32import org.openstreetmap.josm.gui.layer.LayerManager.LayerOrderChangeEvent;
33import org.openstreetmap.josm.gui.layer.LayerManager.LayerRemoveEvent;
34import org.openstreetmap.josm.gui.util.GuiHelper;
35import org.openstreetmap.josm.testutils.ExpectedRootException;
36import org.openstreetmap.josm.tools.bugreport.ReportedException;
37
38/**
39 * Test the {@link LayerManager} class.
40 * @author Michael Zangl
41 *
42 */
43public class LayerManagerTest {
44 /**
45 * This is a layer that can be used in tests. It does not do anything and provides a simple, fake implementation.
46 * @author Michael Zangl
47 */
48 public static class TestLayer extends Layer {
49 /**
50 * Create a new test layer.
51 */
52 public TestLayer() {
53 super("Test Layer");
54 }
55
56 @Override
57 public void paint(Graphics2D g, MapView mv, Bounds bbox) {
58 }
59
60 @Override
61 public void visitBoundingBox(BoundingXYVisitor v) {
62 }
63
64 @Override
65 public void mergeFrom(Layer from) {
66 }
67
68 @Override
69 public boolean isMergable(Layer other) {
70 return false;
71 }
72
73 @Override
74 public String getToolTipText() {
75 return null;
76 }
77
78 @Override
79 public Action[] getMenuEntries() {
80 return new Action[0];
81 }
82
83 @Override
84 public Object getInfoComponent() {
85 return null;
86 }
87
88 @Override
89 public Icon getIcon() {
90 return new Icon() {
91 @Override
92 public void paintIcon(Component c, Graphics g, int x, int y) {
93 // nop
94 }
95
96 @Override
97 public int getIconWidth() {
98 return 10;
99 }
100
101 @Override
102 public int getIconHeight() {
103 return 10;
104 }
105 };
106 }
107
108 @Override
109 public LayerPositionStrategy getDefaultLayerPosition() {
110 return LayerPositionStrategy.afterLast(o -> true);
111 }
112 }
113
114 protected static class TestLayer2 extends TestLayer {}
115
116 /**
117 * Intercepts the events for easier testing.
118 * @author Michael Zangl
119 *
120 */
121 protected class CapturingLayerChangeListener implements LayerChangeListener {
122 protected LayerAddEvent layerAdded;
123 protected LayerRemoveEvent layerRemoved;
124 protected LayerOrderChangeEvent layerOrderChanged;
125
126 @Override
127 public void layerAdded(LayerAddEvent e) {
128 GuiHelper.assertCallFromEdt();
129 assertNull(layerAdded);
130 assertSame(layerManager, e.getSource());
131 layerAdded = e;
132 }
133
134 @Override
135 public void layerRemoving(LayerRemoveEvent e) {
136 GuiHelper.assertCallFromEdt();
137 assertNull(layerRemoved);
138 assertSame(layerManager, e.getSource());
139 layerRemoved = e;
140 }
141
142 @Override
143 public void layerOrderChanged(LayerOrderChangeEvent e) {
144 GuiHelper.assertCallFromEdt();
145 assertNull(layerOrderChanged);
146 assertSame(layerManager, e.getSource());
147 layerOrderChanged = e;
148 }
149 }
150
151 private final class ResetStateChangeListener extends CapturingLayerChangeListener {
152 int removed = 0;
153
154 @Override
155 public void layerRemoving(LayerRemoveEvent e) {
156 // count only
157 removed++;
158 }
159 }
160
161 protected LayerManager layerManager;
162
163 /**
164 * Rule used to expect exceptions.
165 */
166 @Rule
167 public ExpectedRootException thrown = ExpectedRootException.none();
168
169 /**
170 * Set up test layer manager.
171 */
172 @Before
173 public void setUp() {
174 layerManager = new LayerManager();
175 }
176
177 /**
178 * {@link LayerManager#addLayer(Layer)}
179 */
180 @Test
181 public void testAddLayer() {
182 Layer layer1 = new TestLayer() {
183 @Override
184 public LayerPositionStrategy getDefaultLayerPosition() {
185 return LayerPositionStrategy.IN_FRONT;
186 }
187
188 @Override
189 public boolean isBackgroundLayer() {
190 return true;
191 }
192 };
193 Layer layer2 = new TestLayer() {
194 @Override
195 public LayerPositionStrategy getDefaultLayerPosition() {
196 return LayerPositionStrategy.IN_FRONT;
197 }
198 };
199 Layer layer3 = new TestLayer() {
200 @Override
201 public LayerPositionStrategy getDefaultLayerPosition() {
202 return LayerPositionStrategy.BEFORE_FIRST_BACKGROUND_LAYER;
203 }
204 };
205
206 layerManager.addLayer(layer1);
207 assertEquals(layerManager.getLayers(), Arrays.asList(layer1));
208 layerManager.addLayer(layer2);
209 assertEquals(layerManager.getLayers(), Arrays.asList(layer2, layer1));
210 layerManager.addLayer(layer3);
211 assertEquals(layerManager.getLayers(), Arrays.asList(layer2, layer3, layer1));
212
213 // event
214 TestLayer layer4 = new TestLayer();
215 CapturingLayerChangeListener l = new CapturingLayerChangeListener();
216 layerManager.addLayerChangeListener(l);
217 layerManager.addLayer(layer4);
218
219 assertSame(layer4, l.layerAdded.getAddedLayer());
220 assertNull(l.layerRemoved);
221 assertNull(l.layerOrderChanged);
222 }
223
224 /**
225 * {@link LayerManager#addLayer(Layer)}: duplicate layers
226 */
227 @Test
228 public void testAddLayerFails() {
229 thrown.expect(ReportedException.class);
230 thrown.expectCause(any(InvocationTargetException.class));
231 thrown.expectRootCause(any(IllegalArgumentException.class));
232
233 TestLayer layer1 = new TestLayer();
234 layerManager.addLayer(layer1);
235 layerManager.addLayer(layer1);
236 }
237
238 /**
239 * {@link LayerManager#addLayer(Layer)}: illegal default layer position
240 */
241 @Test
242 public void testAddLayerIllegalPosition() {
243 thrown.expect(ReportedException.class);
244 thrown.expectCause(any(InvocationTargetException.class));
245 thrown.expectRootCause(any(IndexOutOfBoundsException.class));
246
247 TestLayer layer1 = new TestLayer() {
248 @Override
249 public LayerPositionStrategy getDefaultLayerPosition() {
250 return manager -> 42;
251 }
252 };
253 layerManager.addLayer(layer1);
254 }
255
256 /**
257 * {@link LayerManager#removeLayer(Layer)}
258 */
259 @Test
260 public void testRemoveLayer() {
261 TestLayer layer1 = new TestLayer();
262 TestLayer layer2 = new TestLayer();
263 layerManager.addLayer(layer1);
264 layerManager.addLayer(layer2);
265 assertEquals(layerManager.getLayers(), Arrays.asList(layer1, layer2));
266
267 CapturingLayerChangeListener l = new CapturingLayerChangeListener();
268 layerManager.addLayerChangeListener(l);
269 layerManager.removeLayer(layer2);
270 assertEquals(layerManager.getLayers(), Arrays.asList(layer1));
271
272 assertNull(l.layerAdded);
273 assertSame(layer2, l.layerRemoved.getRemovedLayer());
274 assertNull(l.layerOrderChanged);
275 }
276
277 /**
278 * {@link LayerManager#moveLayer(Layer, int)}
279 */
280 @Test
281 public void testMoveLayer() {
282 TestLayer layer1 = new TestLayer();
283 TestLayer layer2 = new TestLayer();
284 layerManager.addLayer(layer1);
285 layerManager.addLayer(layer2);
286 assertEquals(layerManager.getLayers(), Arrays.asList(layer1, layer2));
287
288 layerManager.moveLayer(layer2, 0);
289 assertEquals(layerManager.getLayers(), Arrays.asList(layer2, layer1));
290
291 CapturingLayerChangeListener l = new CapturingLayerChangeListener();
292 layerManager.addLayerChangeListener(l);
293 layerManager.moveLayer(layer2, 1);
294 assertEquals(layerManager.getLayers(), Arrays.asList(layer1, layer2));
295
296 assertNull(l.layerAdded);
297 assertNull(l.layerRemoved);
298 assertNotNull(l.layerOrderChanged);
299
300 // This should not change anything and not fire any event
301 layerManager.moveLayer(layer2, 1);
302 assertEquals(layerManager.getLayers(), Arrays.asList(layer1, layer2));
303 }
304
305 /**
306 * {@link LayerManager#moveLayer(Layer, int)} fails for wrong index
307 */
308 @Test
309 public void testMoveLayerFailsRange() {
310 thrown.expect(ReportedException.class);
311 thrown.expectCause(any(InvocationTargetException.class));
312 thrown.expectRootCause(any(IndexOutOfBoundsException.class));
313
314 TestLayer layer1 = new TestLayer();
315 TestLayer layer2 = new TestLayer();
316 layerManager.addLayer(layer1);
317 layerManager.addLayer(layer2);
318 layerManager.moveLayer(layer2, 2);
319 }
320
321 /**
322 * {@link LayerManager#moveLayer(Layer, int)} fails for wrong layer
323 */
324 @Test
325 public void testMoveLayerFailsNotInList() {
326 thrown.expect(ReportedException.class);
327 thrown.expectCause(any(InvocationTargetException.class));
328 thrown.expectRootCause(any(IllegalArgumentException.class));
329
330 TestLayer layer1 = new TestLayer();
331 TestLayer layer2 = new TestLayer();
332 layerManager.addLayer(layer1);
333 layerManager.moveLayer(layer2, 0);
334 }
335
336 /**
337 * {@link LayerManager#getLayers()} unmodifiable
338 */
339 @Test(expected = UnsupportedOperationException.class)
340 public void testGetLayers() {
341 // list should be immutable
342 TestLayer layer1 = new TestLayer();
343 TestLayer layer2 = new TestLayer();
344 layerManager.addLayer(layer1);
345 layerManager.addLayer(layer2);
346 layerManager.getLayers().remove(0);
347 }
348
349 /**
350 * {@link LayerManager#getLayersOfType(Class)}
351 */
352 @Test
353 public void testGetLayersOfType() {
354 TestLayer2 layer1 = new TestLayer2();
355 TestLayer2 layer2 = new TestLayer2();
356 layerManager.addLayer(layer1);
357 layerManager.addLayer(new TestLayer());
358 layerManager.addLayer(layer2);
359
360 assertEquals(layerManager.getLayersOfType(TestLayer2.class), Arrays.asList(layer1, layer2));
361 }
362
363 /**
364 * {@link LayerManager#containsLayer(Layer)}
365 */
366 @Test
367 public void testContainsLayer() {
368 TestLayer layer = new TestLayer();
369 layerManager.addLayer(layer);
370 layerManager.addLayer(new TestLayer());
371
372 assertTrue(layerManager.containsLayer(layer));
373 assertFalse(layerManager.containsLayer(new TestLayer()));
374 }
375
376 /**
377 * {@link LayerManager#addLayerChangeListener(LayerChangeListener)}
378 */
379 @Test
380 public void testAddLayerChangeListener() {
381 CapturingLayerChangeListener l = new CapturingLayerChangeListener();
382 layerManager.addLayerChangeListener(l);
383 assertNull(l.layerAdded);
384 assertNull(l.layerRemoved);
385 assertNull(l.layerOrderChanged);
386 }
387
388 /**
389 * {@link LayerManager#addLayerChangeListener(LayerChangeListener)} twice
390 */
391 @Test(expected = IllegalArgumentException.class)
392 public void testAddLayerChangeListenerDupplicates() {
393 CapturingLayerChangeListener l = new CapturingLayerChangeListener();
394 layerManager.addLayerChangeListener(l);
395 layerManager.addLayerChangeListener(l);
396 }
397
398 /**
399 * {@link LayerManager#addLayerChangeListener(LayerChangeListener, boolean)} fires fake add events
400 */
401 @Test
402 public void testAddLayerChangeListenerFire() {
403 final ArrayList<Layer> fired = new ArrayList<>();
404 TestLayer layer1 = new TestLayer();
405 TestLayer layer2 = new TestLayer();
406 layerManager.addLayer(layer1);
407 layerManager.addLayer(layer2);
408 layerManager.addLayerChangeListener(new LayerChangeListener() {
409 @Override
410 public void layerRemoving(LayerRemoveEvent e) {
411 fail();
412 }
413
414 @Override
415 public void layerOrderChanged(LayerOrderChangeEvent e) {
416 fail();
417 }
418
419 @Override
420 public void layerAdded(LayerAddEvent e) {
421 fired.add(e.getAddedLayer());
422 }
423 }, true);
424
425 assertEquals(Arrays.asList(layer1, layer2), fired);
426 }
427
428 /**
429 * {@link LayerManager#removeLayerChangeListener(LayerChangeListener)}
430 */
431 @Test
432 public void testRemoveLayerChangeListener() {
433 CapturingLayerChangeListener l = new CapturingLayerChangeListener();
434 layerManager.addLayerChangeListener(l);
435 layerManager.addLayer(new TestLayer());
436 layerManager.removeLayerChangeListener(l);
437 layerManager.addLayer(new TestLayer());
438 // threw exception when fired twice.
439 assertNotNull(l.layerAdded);
440 assertNull(l.layerRemoved);
441 assertNull(l.layerOrderChanged);
442 }
443
444 /**
445 * {@link LayerManager#removeLayerChangeListener(LayerChangeListener)} listener not in list
446 */
447 @Test(expected = IllegalArgumentException.class)
448 public void testRemoveLayerChangeListenerNotAdded() {
449 CapturingLayerChangeListener l = new CapturingLayerChangeListener();
450 layerManager.removeLayerChangeListener(l);
451 }
452
453 /**
454 * {@link LayerManager#removeLayerChangeListener(LayerChangeListener, boolean)} fires fake remove events
455 */
456 @Test
457 public void testRemoveLayerChangeListenerFire() {
458 final ArrayList<Layer> fired = new ArrayList<>();
459 TestLayer layer1 = new TestLayer();
460 TestLayer layer2 = new TestLayer();
461 layerManager.addLayer(layer1);
462 layerManager.addLayer(layer2);
463 LayerChangeListener listener = new LayerChangeListener() {
464 @Override
465 public void layerRemoving(LayerRemoveEvent e) {
466 fired.add(e.getRemovedLayer());
467 }
468
469 @Override
470 public void layerOrderChanged(LayerOrderChangeEvent e) {
471 fail();
472 }
473
474 @Override
475 public void layerAdded(LayerAddEvent e) {
476 fail();
477 }
478 };
479 layerManager.addLayerChangeListener(listener, false);
480 layerManager.removeLayerChangeListener(listener, true);
481
482 assertEquals(Arrays.asList(layer1, layer2), fired);
483 }
484
485 /**
486 * Test {@link LayerRemoveEvent#scheduleRemoval(java.util.Collection)}
487 */
488 @Test
489 public void testLayerRemoveScheduleRemoval() {
490 TestLayer layer1 = new TestLayer();
491 TestLayer layer2 = new TestLayer();
492 layerManager.addLayer(layer1);
493 layerManager.addLayer(layer2);
494
495 layerManager.addLayerChangeListener(new LayerChangeListener() {
496 @Override
497 public void layerRemoving(LayerRemoveEvent e) {
498 if (e.getRemovedLayer() == layer1) {
499 e.scheduleRemoval(Collections.singleton(layer2));
500 }
501 }
502
503 @Override
504 public void layerOrderChanged(LayerOrderChangeEvent e) {
505 fail();
506 }
507
508 @Override
509 public void layerAdded(LayerAddEvent e) {
510 fail();
511 }
512 });
513
514 layerManager.removeLayer(layer1);
515 assertEquals(0, layerManager.getLayers().size());
516 }
517
518 /**
519 * Test {@link LayerManager#resetState()}
520 */
521 @Test
522 public void testResetState() {
523 ResetStateChangeListener changeListener = new ResetStateChangeListener();
524 layerManager.addLayer(new TestLayer());
525 layerManager.addLayerChangeListener(changeListener);
526 layerManager.addLayer(new TestLayer());
527 assertEquals(2, layerManager.getLayers().size());
528 assertNotNull(changeListener.layerAdded);
529
530 layerManager.resetState();
531 changeListener.layerAdded = null;
532
533 assertEquals(2, changeListener.removed);
534 assertEquals(0, layerManager.getLayers().size());
535 layerManager.addLayer(new TestLayer());
536 assertNull(changeListener.layerAdded);
537 }
538
539}
Note: See TracBrowser for help on using the repository browser.