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

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

sonar - squid:S2301 - Public methods should not contain selector arguments
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 /** the tested layer manager */
162 protected LayerManager layerManager;
163
164 /**
165 * Rule used to expect exceptions.
166 */
167 @Rule
168 public ExpectedRootException thrown = ExpectedRootException.none();
169
170 /**
171 * Set up test layer manager.
172 */
173 @Before
174 public void setUp() {
175 layerManager = new LayerManager();
176 }
177
178 /**
179 * {@link LayerManager#addLayer(Layer)}
180 */
181 @Test
182 public void testAddLayer() {
183 Layer layer1 = new TestLayer() {
184 @Override
185 public LayerPositionStrategy getDefaultLayerPosition() {
186 return LayerPositionStrategy.IN_FRONT;
187 }
188
189 @Override
190 public boolean isBackgroundLayer() {
191 return true;
192 }
193 };
194 Layer layer2 = new TestLayer() {
195 @Override
196 public LayerPositionStrategy getDefaultLayerPosition() {
197 return LayerPositionStrategy.IN_FRONT;
198 }
199 };
200 Layer layer3 = new TestLayer() {
201 @Override
202 public LayerPositionStrategy getDefaultLayerPosition() {
203 return LayerPositionStrategy.BEFORE_FIRST_BACKGROUND_LAYER;
204 }
205 };
206
207 layerManager.addLayer(layer1);
208 assertEquals(layerManager.getLayers(), Arrays.asList(layer1));
209 layerManager.addLayer(layer2);
210 assertEquals(layerManager.getLayers(), Arrays.asList(layer2, layer1));
211 layerManager.addLayer(layer3);
212 assertEquals(layerManager.getLayers(), Arrays.asList(layer2, layer3, layer1));
213
214 // event
215 TestLayer layer4 = new TestLayer();
216 CapturingLayerChangeListener l = new CapturingLayerChangeListener();
217 layerManager.addLayerChangeListener(l);
218 layerManager.addLayer(layer4);
219
220 assertSame(layer4, l.layerAdded.getAddedLayer());
221 assertNull(l.layerRemoved);
222 assertNull(l.layerOrderChanged);
223 }
224
225 /**
226 * {@link LayerManager#addLayer(Layer)}: duplicate layers
227 */
228 @Test
229 public void testAddLayerFails() {
230 thrown.expect(ReportedException.class);
231 thrown.expectCause(any(InvocationTargetException.class));
232 thrown.expectRootCause(any(IllegalArgumentException.class));
233
234 TestLayer layer1 = new TestLayer();
235 layerManager.addLayer(layer1);
236 layerManager.addLayer(layer1);
237 }
238
239 /**
240 * {@link LayerManager#addLayer(Layer)}: illegal default layer position
241 */
242 @Test
243 public void testAddLayerIllegalPosition() {
244 thrown.expect(ReportedException.class);
245 thrown.expectCause(any(InvocationTargetException.class));
246 thrown.expectRootCause(any(IndexOutOfBoundsException.class));
247
248 TestLayer layer1 = new TestLayer() {
249 @Override
250 public LayerPositionStrategy getDefaultLayerPosition() {
251 return manager -> 42;
252 }
253 };
254 layerManager.addLayer(layer1);
255 }
256
257 /**
258 * {@link LayerManager#removeLayer(Layer)}
259 */
260 @Test
261 public void testRemoveLayer() {
262 TestLayer layer1 = new TestLayer();
263 TestLayer layer2 = new TestLayer();
264 layerManager.addLayer(layer1);
265 layerManager.addLayer(layer2);
266 assertEquals(layerManager.getLayers(), Arrays.asList(layer1, layer2));
267
268 CapturingLayerChangeListener l = new CapturingLayerChangeListener();
269 layerManager.addLayerChangeListener(l);
270 layerManager.removeLayer(layer2);
271 assertEquals(layerManager.getLayers(), Arrays.asList(layer1));
272
273 assertNull(l.layerAdded);
274 assertSame(layer2, l.layerRemoved.getRemovedLayer());
275 assertNull(l.layerOrderChanged);
276 }
277
278 /**
279 * {@link LayerManager#moveLayer(Layer, int)}
280 */
281 @Test
282 public void testMoveLayer() {
283 TestLayer layer1 = new TestLayer();
284 TestLayer layer2 = new TestLayer();
285 layerManager.addLayer(layer1);
286 layerManager.addLayer(layer2);
287 assertEquals(layerManager.getLayers(), Arrays.asList(layer1, layer2));
288
289 layerManager.moveLayer(layer2, 0);
290 assertEquals(layerManager.getLayers(), Arrays.asList(layer2, layer1));
291
292 CapturingLayerChangeListener l = new CapturingLayerChangeListener();
293 layerManager.addLayerChangeListener(l);
294 layerManager.moveLayer(layer2, 1);
295 assertEquals(layerManager.getLayers(), Arrays.asList(layer1, layer2));
296
297 assertNull(l.layerAdded);
298 assertNull(l.layerRemoved);
299 assertNotNull(l.layerOrderChanged);
300
301 // This should not change anything and not fire any event
302 layerManager.moveLayer(layer2, 1);
303 assertEquals(layerManager.getLayers(), Arrays.asList(layer1, layer2));
304 }
305
306 /**
307 * {@link LayerManager#moveLayer(Layer, int)} fails for wrong index
308 */
309 @Test
310 public void testMoveLayerFailsRange() {
311 thrown.expect(ReportedException.class);
312 thrown.expectCause(any(InvocationTargetException.class));
313 thrown.expectRootCause(any(IndexOutOfBoundsException.class));
314
315 TestLayer layer1 = new TestLayer();
316 TestLayer layer2 = new TestLayer();
317 layerManager.addLayer(layer1);
318 layerManager.addLayer(layer2);
319 layerManager.moveLayer(layer2, 2);
320 }
321
322 /**
323 * {@link LayerManager#moveLayer(Layer, int)} fails for wrong layer
324 */
325 @Test
326 public void testMoveLayerFailsNotInList() {
327 thrown.expect(ReportedException.class);
328 thrown.expectCause(any(InvocationTargetException.class));
329 thrown.expectRootCause(any(IllegalArgumentException.class));
330
331 TestLayer layer1 = new TestLayer();
332 TestLayer layer2 = new TestLayer();
333 layerManager.addLayer(layer1);
334 layerManager.moveLayer(layer2, 0);
335 }
336
337 /**
338 * {@link LayerManager#getLayers()} unmodifiable
339 */
340 @Test(expected = UnsupportedOperationException.class)
341 public void testGetLayers() {
342 // list should be immutable
343 TestLayer layer1 = new TestLayer();
344 TestLayer layer2 = new TestLayer();
345 layerManager.addLayer(layer1);
346 layerManager.addLayer(layer2);
347 layerManager.getLayers().remove(0);
348 }
349
350 /**
351 * {@link LayerManager#getLayersOfType(Class)}
352 */
353 @Test
354 public void testGetLayersOfType() {
355 TestLayer2 layer1 = new TestLayer2();
356 TestLayer2 layer2 = new TestLayer2();
357 layerManager.addLayer(layer1);
358 layerManager.addLayer(new TestLayer());
359 layerManager.addLayer(layer2);
360
361 assertEquals(layerManager.getLayersOfType(TestLayer2.class), Arrays.asList(layer1, layer2));
362 }
363
364 /**
365 * {@link LayerManager#containsLayer(Layer)}
366 */
367 @Test
368 public void testContainsLayer() {
369 TestLayer layer = new TestLayer();
370 layerManager.addLayer(layer);
371 layerManager.addLayer(new TestLayer());
372
373 assertTrue(layerManager.containsLayer(layer));
374 assertFalse(layerManager.containsLayer(new TestLayer()));
375 }
376
377 /**
378 * {@link LayerManager#addLayerChangeListener(LayerChangeListener)}
379 */
380 @Test
381 public void testAddLayerChangeListener() {
382 CapturingLayerChangeListener l = new CapturingLayerChangeListener();
383 layerManager.addLayerChangeListener(l);
384 assertNull(l.layerAdded);
385 assertNull(l.layerRemoved);
386 assertNull(l.layerOrderChanged);
387 }
388
389 /**
390 * {@link LayerManager#addLayerChangeListener(LayerChangeListener)} twice
391 */
392 @Test(expected = IllegalArgumentException.class)
393 public void testAddLayerChangeListenerDupplicates() {
394 CapturingLayerChangeListener l = new CapturingLayerChangeListener();
395 layerManager.addLayerChangeListener(l);
396 layerManager.addLayerChangeListener(l);
397 }
398
399 /**
400 * {@link LayerManager#addAndFireLayerChangeListener(LayerChangeListener)} fires fake add events
401 */
402 @Test
403 public void testAddLayerChangeListenerFire() {
404 final ArrayList<Layer> fired = new ArrayList<>();
405 TestLayer layer1 = new TestLayer();
406 TestLayer layer2 = new TestLayer();
407 layerManager.addLayer(layer1);
408 layerManager.addLayer(layer2);
409 layerManager.addAndFireLayerChangeListener(new LayerChangeListener() {
410 @Override
411 public void layerRemoving(LayerRemoveEvent e) {
412 fail();
413 }
414
415 @Override
416 public void layerOrderChanged(LayerOrderChangeEvent e) {
417 fail();
418 }
419
420 @Override
421 public void layerAdded(LayerAddEvent e) {
422 fired.add(e.getAddedLayer());
423 }
424 });
425
426 assertEquals(Arrays.asList(layer1, layer2), fired);
427 }
428
429 /**
430 * {@link LayerManager#removeLayerChangeListener(LayerChangeListener)}
431 */
432 @Test
433 public void testRemoveLayerChangeListener() {
434 CapturingLayerChangeListener l = new CapturingLayerChangeListener();
435 layerManager.addLayerChangeListener(l);
436 layerManager.addLayer(new TestLayer());
437 layerManager.removeLayerChangeListener(l);
438 layerManager.addLayer(new TestLayer());
439 // threw exception when fired twice.
440 assertNotNull(l.layerAdded);
441 assertNull(l.layerRemoved);
442 assertNull(l.layerOrderChanged);
443 }
444
445 /**
446 * {@link LayerManager#removeLayerChangeListener(LayerChangeListener)} listener not in list
447 */
448 @Test(expected = IllegalArgumentException.class)
449 public void testRemoveLayerChangeListenerNotAdded() {
450 CapturingLayerChangeListener l = new CapturingLayerChangeListener();
451 layerManager.removeLayerChangeListener(l);
452 }
453
454 /**
455 * {@link LayerManager#removeAndFireLayerChangeListener(LayerChangeListener)} fires fake remove events
456 */
457 @Test
458 public void testRemoveLayerChangeListenerFire() {
459 final ArrayList<Layer> fired = new ArrayList<>();
460 TestLayer layer1 = new TestLayer();
461 TestLayer layer2 = new TestLayer();
462 layerManager.addLayer(layer1);
463 layerManager.addLayer(layer2);
464 LayerChangeListener listener = new LayerChangeListener() {
465 @Override
466 public void layerRemoving(LayerRemoveEvent e) {
467 fired.add(e.getRemovedLayer());
468 }
469
470 @Override
471 public void layerOrderChanged(LayerOrderChangeEvent e) {
472 fail();
473 }
474
475 @Override
476 public void layerAdded(LayerAddEvent e) {
477 fail();
478 }
479 };
480 layerManager.addLayerChangeListener(listener);
481 layerManager.removeAndFireLayerChangeListener(listener);
482
483 assertEquals(Arrays.asList(layer1, layer2), fired);
484 }
485
486 /**
487 * Test {@link LayerRemoveEvent#scheduleRemoval(java.util.Collection)}
488 */
489 @Test
490 public void testLayerRemoveScheduleRemoval() {
491 TestLayer layer1 = new TestLayer();
492 TestLayer layer2 = new TestLayer();
493 layerManager.addLayer(layer1);
494 layerManager.addLayer(layer2);
495
496 layerManager.addLayerChangeListener(new LayerChangeListener() {
497 @Override
498 public void layerRemoving(LayerRemoveEvent e) {
499 if (e.getRemovedLayer() == layer1) {
500 e.scheduleRemoval(Collections.singleton(layer2));
501 }
502 }
503
504 @Override
505 public void layerOrderChanged(LayerOrderChangeEvent e) {
506 fail();
507 }
508
509 @Override
510 public void layerAdded(LayerAddEvent e) {
511 fail();
512 }
513 });
514
515 layerManager.removeLayer(layer1);
516 assertEquals(0, layerManager.getLayers().size());
517 }
518
519 /**
520 * Test {@link LayerManager#resetState()}
521 */
522 @Test
523 public void testResetState() {
524 ResetStateChangeListener changeListener = new ResetStateChangeListener();
525 layerManager.addLayer(new TestLayer());
526 layerManager.addLayerChangeListener(changeListener);
527 layerManager.addLayer(new TestLayer());
528 assertEquals(2, layerManager.getLayers().size());
529 assertNotNull(changeListener.layerAdded);
530
531 layerManager.resetState();
532 changeListener.layerAdded = null;
533
534 assertEquals(2, changeListener.removed);
535 assertEquals(0, layerManager.getLayers().size());
536 layerManager.addLayer(new TestLayer());
537 assertNull(changeListener.layerAdded);
538 }
539
540}
Note: See TracBrowser for help on using the repository browser.