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

Last change on this file was 17275, checked in by Don-vip, 3 years ago

see #16567 - upgrade almost all tests to JUnit 5, except those depending on WiremockRule

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