Changeset 14052 in josm for trunk/test/unit/org/openstreetmap

Timestamp:

2018-07-26T22:01:31+02:00 (6 years ago)

Author:

Don-vip

Message:

see #16010 - use JMockit to enable more extensive test coverage (patch by ris, modified)

see ​https://github.com/openstreetmap/josm/pull/24/commits for details

Location:

trunk/test/unit/org/openstreetmap/josm

Files:

• TestUtils.java (modified) (6 diffs)
• actions/ExitActionTest.java (modified) (2 diffs)
• actions/downloadtasks/PluginDownloadTaskTest.java (modified) (5 diffs)
• gui/dialogs/MinimapDialogTest.java (modified) (7 diffs)
• gui/io/AsynchronousUploadPrimitivesTaskTest.java (modified) (5 diffs)
• gui/preferences/advanced/ExportProfileActionTest.java (modified) (3 diffs)
• gui/preferences/advanced/PreferencesTableTest.java (modified) (3 diffs)
• gui/preferences/plugin/PluginPreferenceHighLevelTest.java (added)
• gui/preferences/plugin/PluginPreferenceTest.java (modified) (5 diffs)
• plugins/PluginHandlerJOSMTooOldTest.java (added)
• testutils/JOSMTestRules.java (modified) (15 diffs)
• testutils/PluginServer.java (added)
• testutils/mockers (added)
• testutils/mockers/BaseDialogMockUp.java (added)
• testutils/mockers/EDTAssertionMocker.java (added)
• testutils/mockers/ExtendedDialogMocker.java (added)
• testutils/mockers/HelpAwareOptionPaneMocker.java (added)
• testutils/mockers/JOptionPaneSimpleMocker.java (added)
• testutils/mockers/WindowMocker.java (added)
• testutils/mockers/WindowlessMapViewStateMocker.java (added)
• testutils/mockers/WindowlessNavigatableComponentMocker.java (added)

trunk/test/unit/org/openstreetmap/josm/TestUtils.java

@@ -3 +3 @@
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
@@ -9 +11 @@
 import java.awt.Graphics2D;
 import java.io.File;
+import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
@@ -23 +26 @@
 import java.util.Comparator;
 import java.util.Objects;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ThreadPoolExecutor;
 import java.util.stream.Stream;
 
@@ -34 +39 @@
 import org.openstreetmap.josm.data.osm.RelationMember;
 import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.gui.MainApplication;
 import org.openstreetmap.josm.gui.progress.AbstractProgressMonitor;
 import org.openstreetmap.josm.gui.progress.CancelHandler;
 import org.openstreetmap.josm.gui.progress.ProgressMonitor;
 import org.openstreetmap.josm.gui.progress.ProgressTaskId;
+import org.openstreetmap.josm.gui.util.GuiHelper;
 import org.openstreetmap.josm.io.Compression;
 import org.openstreetmap.josm.testutils.FakeGraphics;
@@ -45 +52 @@
 import com.github.tomakehurst.wiremock.WireMockServer;
 import com.github.tomakehurst.wiremock.core.WireMockConfiguration;
+
+import com.google.common.io.ByteStreams;
 
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
@@ -429 +438 @@
         return getHTTPDate(Instant.ofEpochMilli(time));
     }
+
+    /**
+     * Throws AssertionError if contents of both files are not equal
+     * @param fileA File A
+     * @param fileB File B
+     */
+    public static void assertFileContentsEqual(final File fileA, final File fileB) {
+        assertTrue(fileA.exists());
+        assertTrue(fileA.canRead());
+        assertTrue(fileB.exists());
+        assertTrue(fileB.canRead());
+        try {
+            try (
+                FileInputStream streamA = new FileInputStream(fileA);
+                FileInputStream streamB = new FileInputStream(fileB);
+            ) {
+                assertArrayEquals(
+                    ByteStreams.toByteArray(streamA),
+                    ByteStreams.toByteArray(streamB)
+                );
+            }
+        } catch (IOException e) {
+            fail(e.toString());
+        }
+    }
+
+    /**
+     * Waits until any asynchronous operations launched by the test on the EDT or worker threads have
+     * (almost certainly) completed.
+     */
+    public static void syncEDTAndWorkerThreads() {
+        boolean workerQueueEmpty = false;
+        while (!workerQueueEmpty) {
+            try {
+                // once our own task(s) have made it to the front of their respective queue(s),
+                // they're both executing at the same time and we know there aren't any outstanding
+                // worker tasks, then presumably the only way there could be incomplete operations
+                // is if the EDT had launched a deferred task to run on itself or perhaps set up a
+                // swing timer - neither are particularly common patterns in JOSM (?)
+                //
+                // there shouldn't be a risk of creating a deadlock in doing this as there shouldn't
+                // (...couldn't?) be EDT operations waiting on the results of a worker task.
+                workerQueueEmpty = MainApplication.worker.submit(
+                    () -> GuiHelper.runInEDTAndWaitAndReturn(
+                        () -> ((ThreadPoolExecutor) MainApplication.worker).getQueue().isEmpty()
+                    )
+                ).get();
+            } catch (InterruptedException | ExecutionException e) {
+                // inconclusive - retry...
+                workerQueueEmpty = false;
+            }
+        }
+    }
 }

trunk/test/unit/org/openstreetmap/josm/actions/ExitActionTest.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.actions;
+
+import static org.junit.Assert.assertTrue;
 
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.contrib.java.lang.system.ExpectedSystemExit;
+import org.openstreetmap.josm.gui.MainApplication;
+import org.openstreetmap.josm.gui.progress.swing.ProgressMonitorExecutor;
 import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.openstreetmap.josm.tools.ImageProvider;
+
+import mockit.Invocation;
+import mockit.Mock;
+import mockit.MockUp;
 
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
@@ -33 +42 @@
     public void testActionPerformed() {
         exit.expectSystemExitWithStatus(0);
+
+        boolean[] workerShutdownCalled = {false};
+        boolean[] workerShutdownNowCalled = {false};
+        boolean[] imageProviderShutdownCalled = {false};
+
+        // critically we don't proceed into the actual implementation in any of these mock methods -
+        // that would be quite annoying for tests following this one which were expecting to use any
+        // of these
+        new MockUp<ProgressMonitorExecutor>() {
+            @Mock
+            private void shutdown(Invocation invocation) {
+                if (invocation.getInvokedInstance() == MainApplication.worker) {
+                    workerShutdownCalled[0] = true;
+                }
+            }
+
+            @Mock
+            private void shutdownNow(Invocation invocation) {
+                if (invocation.getInvokedInstance() == MainApplication.worker) {
+                    // regular shutdown should have been called first
+                    assertTrue(workerShutdownCalled[0]);
+                    workerShutdownNowCalled[0] = true;
+                }
+            }
+        };
+        new MockUp<ImageProvider>() {
+            @Mock
+            private void shutdown(Invocation invocation) {
+                imageProviderShutdownCalled[0] = true;
+            }
+        };
+
         // No layer
+
         new ExitAction().actionPerformed(null);
+
+        assertTrue(workerShutdownCalled[0]);
+        assertTrue(workerShutdownNowCalled[0]);
+        assertTrue(imageProviderShutdownCalled[0]);
     }
 }

trunk/test/unit/org/openstreetmap/josm/actions/downloadtasks/PluginDownloadTaskTest.java

@@ -56 +56 @@
     @Test
     public void testUpdatePluginValid() throws Exception {
-        this.pluginPath = "plugin/dummy_plugin.jar";
+        this.pluginPath = "plugin/dummy_plugin.v31772.jar";
         this.mockHttp();
 
@@ -74 +74 @@
 
         // get PluginInformation from jar file
-        final PluginInformation pluginInformation = new PluginInformation(srcPluginFile);
+        final PluginInformation pluginInformation = new PluginInformation(srcPluginFile, "dummy_plugin");
         // ...and grafting on the downloadlink
         pluginInformation.downloadlink = this.getRemoteFileUrl();
@@ -87 +87 @@
         // the ".jar.new" file should have been deleted
         assertFalse(pluginFileNew.exists());
-        // the ".jar" file should still exist
-        assertTrue(pluginFile.exists());
-        try (
-            FileInputStream pluginDirPluginStream = new FileInputStream(pluginFile);
-            FileInputStream srcPluginStream = new FileInputStream(srcPluginFile);
-        ) {
-            // and its contents should equal those that were served to the task
-            assertArrayEquals(
-                ByteStreams.toByteArray(pluginDirPluginStream),
-                ByteStreams.toByteArray(srcPluginStream)
-            );
-        }
+        // the ".jar" file should still exist and its contents should equal those that were served to the task
+        TestUtils.assertFileContentsEqual(pluginFile, srcPluginFile);
     }
 
@@ -140 +130 @@
         }
 
-        // the ".jar.new" file should exist, even though invalid
-        assertTrue(pluginFileNew.exists());
+        // assert that the "corrupt" jar file made it through in tact
+        TestUtils.assertFileContentsEqual(pluginFileNew, srcPluginFile);
         // the ".jar" file should still exist
         assertTrue(pluginFile.exists());
         try (
-            FileInputStream pluginDirPluginNewStream = new FileInputStream(pluginFileNew);
             FileInputStream pluginDirPluginStream = new FileInputStream(pluginFile);
-            FileInputStream srcPluginStream = new FileInputStream(srcPluginFile);
         ) {
             // the ".jar" file's contents should be as before
@@ -154 +142 @@
                 ByteStreams.toByteArray(pluginDirPluginStream)
             );
-            // just assert that the "corrupt" jar file made it through in tact
-            assertArrayEquals(
-                ByteStreams.toByteArray(pluginDirPluginNewStream),
-                ByteStreams.toByteArray(srcPluginStream)
-            );
         }
     }

trunk/test/unit/org/openstreetmap/josm/gui/dialogs/MinimapDialogTest.java

@@ -3 +3 @@
 
 import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static org.openstreetmap.josm.tools.I18n.tr;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
@@ -19 +20 @@
 
 import javax.swing.JMenuItem;
+import javax.swing.JCheckBoxMenuItem;
 import javax.swing.JPopupMenu;
 
@@ -27 +29 @@
 import org.openstreetmap.josm.TestUtils;
 import org.openstreetmap.josm.data.Bounds;
+import org.openstreetmap.josm.data.DataSource;
+import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.data.projection.Projections;
 import org.openstreetmap.josm.gui.MainApplication;
@@ -32 +36 @@
 import org.openstreetmap.josm.gui.bbox.SlippyMapBBoxChooser;
 import org.openstreetmap.josm.gui.bbox.SourceButton;
+import org.openstreetmap.josm.gui.layer.OsmDataLayer;
 import org.openstreetmap.josm.gui.layer.LayerManagerTest.TestLayer;
 import org.openstreetmap.josm.gui.util.GuiHelper;
@@ -87 +92 @@
                 break;
             } else {
-                boolean equalText = ((JMenuItem) c).getText() == label;
+                boolean equalText = ((JMenuItem) c).getText().equals(label);
                 boolean isSelected = ((JMenuItem) c).isSelected();
                 assertEquals(equalText, isSelected);
@@ -297 +302 @@
 
         Map<Integer, String> paletteMap = ImmutableMap.<Integer, String>builder()
-            .put(0xffffffff, "w")
-            .put(0xff000000, "b")
-            .put(0xfff0d1d1, "p")
+            .put(0xffffffff, "w")  // white
+            .put(0xff000000, "b")  // black
+            .put(0xfff0d1d1, "p")  // pink
             .build();
 
@@ -385 +390 @@
         );
     }
+
+    protected JCheckBoxMenuItem getShowDownloadedAreaMenuItem() {
+        JPopupMenu menu = this.sourceButton.getPopupMenu();
+        boolean afterSeparator = false;
+        for (Component c: menu.getComponents()) {
+            if (JPopupMenu.Separator.class.isInstance(c)) {
+                assertFalse("More than one separator before target item", afterSeparator);
+                afterSeparator = true;
+            } else if (((JMenuItem) c).getText().equals(tr("Show downloaded area"))) {
+                assertTrue("Separator not found before target item", afterSeparator);
+                assertTrue("Target item doesn't appear to be a JCheckBoxMenuItem", JCheckBoxMenuItem.class.isInstance(c));
+                return (JCheckBoxMenuItem) c;
+            }
+        }
+        fail("'Show downloaded area' menu item not found");
+        return null;
+    }
+
+    /**
+     * test downloaded area is shown shaded
+     * @throws Exception if any error occurs
+     */
+    @Test
+    public void testShowDownloadedArea() throws Exception {
+        Main.pref.put("slippy_map_chooser.mapstyle", "Green Tiles");
+        Main.pref.putBoolean("slippy_map_chooser.show_downloaded_area", false);
+
+        DataSet dataSet = new DataSet();
+        dataSet.addDataSource(new DataSource(new Bounds(51.725, -0.0209, 51.746, 0.0162), "Somewhere"));
+
+        OsmDataLayer dataLayer = new OsmDataLayer(
+            dataSet,
+            "Test Layer 123",
+            null
+        );
+        MainApplication.getLayerManager().addLayer(dataLayer);
+        MainApplication.getLayerManager().setActiveLayer(dataLayer);
+
+        MapView mapView = MainApplication.getMap().mapView;
+        GuiHelper.runInEDTAndWaitWithException(() -> {
+            mapView.setVisible(true);
+            mapView.addNotify();
+            mapView.doLayout();
+            mapView.setBounds(0, 0, 500, 500);
+        });
+
+        this.setUpMiniMap();
+
+        // assert "show downloaded areas" checkbox is unchecked
+        assertFalse(this.getShowDownloadedAreaMenuItem().isSelected());
+
+        // we won't end up with exactly this viewport as it doesn't *precisely* match the aspect ratio
+        mapView.zoomTo(new Bounds(51.732, -0.0269, 51.753, 0.0102));
+
+        // an initial paint operation is required to trigger the tile fetches
+        this.paintSlippyMap();
+
+        Awaitility.await().atMost(1000, MILLISECONDS).until(this.slippyMapTasksFinished);
+
+        this.paintSlippyMap();
+
+        Map<Integer, String> paletteMap = ImmutableMap.<Integer, String>builder()
+            .put(0xff00ff00, "g")  // green
+            .put(0xff000000, "b")  // black
+            .put(0xff8ad16b, "v")  // viewport marker inner (pink+green mix)
+            .put(0xff00df00, "d")  // (shaded green)
+            .put(0xff8ac46b, "q")  // (shaded pink+green mix)
+            .build();
+
+        // assert downloaded areas are not drawn
+        ImagePatternMatching.rowMatch(
+            paintedSlippyMap,
+            paintedSlippyMap.getHeight()/2,
+            paletteMap,
+            "^g+bv+bg+$",
+            true
+        );
+        ImagePatternMatching.columnMatch(
+            paintedSlippyMap,
+            paintedSlippyMap.getWidth()/2,
+            paletteMap,
+            "^g+bv+bg+$",
+            true
+        );
+
+        // enable "show downloaded areas"
+        GuiHelper.runInEDTAndWaitWithException(() -> this.getShowDownloadedAreaMenuItem().doClick());
+        assertTrue(this.getShowDownloadedAreaMenuItem().isSelected());
+
+        // assert downloaded areas are drawn
+        this.paintSlippyMap();
+
+        ImagePatternMatching.rowMatch(
+            paintedSlippyMap,
+            paintedSlippyMap.getHeight()/2,
+            paletteMap,
+            "^d+bq+v+bg+d+$",
+            true
+        );
+        ImagePatternMatching.columnMatch(
+            paintedSlippyMap,
+            paintedSlippyMap.getWidth()/2,
+            paletteMap,
+            "^d+bq+v+bg+d+$",
+            true
+        );
+
+        // also assert the leftmost column doesn't (yet) have any downloaded area marks (i.e. fully shaded)
+        ImagePatternMatching.columnMatch(
+            paintedSlippyMap,
+            0,
+            paletteMap,
+            "^d+$",
+            true
+        );
+
+        // add another downloaded area, going off the left of the widget
+        dataSet.addDataSource(new DataSource(new Bounds(51.745, -1., 51.765, 0.0162), "Somewhere else"));
+        // and redraw
+        this.paintSlippyMap();
+
+        // the middle row should be as before
+        ImagePatternMatching.rowMatch(
+            paintedSlippyMap,
+            paintedSlippyMap.getHeight()/2,
+            paletteMap,
+            "^d+bq+v+bg+d+$",
+            true
+        );
+        // the middle column should have its unshaded region extended beyond the viewport marker
+        ImagePatternMatching.columnMatch(
+            paintedSlippyMap,
+            paintedSlippyMap.getWidth()/2,
+            paletteMap,
+            "^d+g+bv+bg+d+$",
+            true
+        );
+        // but the leftmost column should now have an unshaded mark
+        ImagePatternMatching.columnMatch(
+            paintedSlippyMap,
+            0,
+            paletteMap,
+            "^d+g+d+$",
+            true
+        );
+        // and the rightmost column should be untouched
+        ImagePatternMatching.columnMatch(
+            paintedSlippyMap,
+            paintedSlippyMap.getWidth()-1,
+            paletteMap,
+            "^d+$",
+            true
+        );
+
+        // and now if we pan to the left (in EastNorth units)
+        mapView.zoomTo(mapView.getCenter().add(-5000., 0.));
+        // and redraw
+        this.paintSlippyMap();
+
+        // the middle row should have its unshaded region outside the viewport marker
+        ImagePatternMatching.rowMatch(
+            paintedSlippyMap,
+            paintedSlippyMap.getHeight()/2,
+            paletteMap,
+            "^d+bq+bd+g+d*$",
+            true
+        );
+        // the middle column should have a shaded region inside the viewport marker
+        ImagePatternMatching.columnMatch(
+            paintedSlippyMap,
+            paintedSlippyMap.getWidth()/2,
+            paletteMap,
+            "^d+g+bv+q+bd+$",
+            true
+        );
+    }
+
+    /**
+     * test display of downloaded area follows active layer switching
+     * @throws Exception if any error occurs
+     */
+    @Test
+    public void testShowDownloadedAreaLayerSwitching() throws Exception {
+        Main.pref.put("slippy_map_chooser.mapstyle", "Green Tiles");
+        Main.pref.putBoolean("slippy_map_chooser.show_downloaded_area", true);
+
+        DataSet dataSetA = new DataSet();
+        // dataSetA has a long thin horizontal downloaded area (extending off the left & right of the map)
+        dataSetA.addDataSource(new DataSource(new Bounds(-18., -61.02, -15., -60.98), "Elsewhere"));
+
+        OsmDataLayer dataLayerA = new OsmDataLayer(
+            dataSetA,
+            "Test Layer A",
+            null
+        );
+        MainApplication.getLayerManager().addLayer(dataLayerA);
+
+        DataSet dataSetB = new DataSet();
+        // dataSetB has a long thin vertical downloaded area (extending off the top & bottom of the map)
+        dataSetB.addDataSource(new DataSource(new Bounds(-16.38, -62., -16.34, -60.), "Nowhere"));
+
+        OsmDataLayer dataLayerB = new OsmDataLayer(
+            dataSetB,
+            "Test Layer B",
+            null
+        );
+        MainApplication.getLayerManager().addLayer(dataLayerB);
+
+        MainApplication.getLayerManager().setActiveLayer(dataLayerB);
+
+        MapView mapView = MainApplication.getMap().mapView;
+        GuiHelper.runInEDTAndWaitWithException(() -> {
+            mapView.setVisible(true);
+            mapView.addNotify();
+            mapView.doLayout();
+            mapView.setBounds(0, 0, 400, 400);
+        });
+
+        this.setUpMiniMap();
+
+        // assert "show downloaded areas" checkbox is checked
+        assertTrue(this.getShowDownloadedAreaMenuItem().isSelected());
+
+        // again, we won't end up with exactly this viewport as it doesn't *precisely* match the aspect ratio
+        mapView.zoomTo(new Bounds(-16.423, -61.076, -16.299, -60.932));
+
+        // an initial paint operation is required to trigger the tile fetches
+        this.paintSlippyMap();
+
+        Awaitility.await().atMost(1000, MILLISECONDS).until(this.slippyMapTasksFinished);
+
+        this.paintSlippyMap();
+
+        Map<Integer, String> paletteMap = ImmutableMap.<Integer, String>builder()
+            .put(0xff00ff00, "g")  // green
+            .put(0xff000000, "b")  // black
+            .put(0xff8ad16b, "v")  // viewport marker inner (pink+green mix)
+            .put(0xff00df00, "d")  // (shaded green)
+            .put(0xff8ac46b, "q")  // (shaded pink+green mix)
+            .build();
+
+        // the middle row should be entirely unshaded
+        ImagePatternMatching.rowMatch(
+            paintedSlippyMap,
+            paintedSlippyMap.getHeight()/2,
+            paletteMap,
+            "^g+bv+bg+$",
+            true
+        );
+        // the middle column should have an unshaded band within the viewport marker
+        Matcher centerMatcher = ImagePatternMatching.columnMatch(
+            paintedSlippyMap,
+            paintedSlippyMap.getWidth()/2,
+            paletteMap,
+            "^(d+bq+)(v+)(q+bd+)$",
+            true
+        );
+        // the leftmost and rightmost columns should have an unshaded band
+        Matcher leftMatcher = ImagePatternMatching.columnMatch(
+            paintedSlippyMap,
+            0,
+            paletteMap,
+            "^(d+)(g+)(d+)$",
+            true
+        );
+        Matcher rightMatcher = ImagePatternMatching.columnMatch(
+            paintedSlippyMap,
+            paintedSlippyMap.getWidth()-1,
+            paletteMap,
+            "^(d+)(g+)(d+)$",
+            true
+        );
+        // the three columns should have the unshaded band in the same place
+        assertEquals(centerMatcher.group(1).length(), leftMatcher.group(1).length());
+        assertEquals(centerMatcher.group(1).length(), rightMatcher.group(1).length());
+        assertEquals(centerMatcher.group(2).length(), leftMatcher.group(2).length());
+        assertEquals(centerMatcher.group(2).length(), rightMatcher.group(2).length());
+
+        // switch active layer
+        MainApplication.getLayerManager().setActiveLayer(dataLayerA);
+        this.paintSlippyMap();
+
+        // the middle column should be entirely unshaded
+        ImagePatternMatching.columnMatch(
+            paintedSlippyMap,
+            paintedSlippyMap.getWidth()/2,
+            paletteMap,
+            "^g+bv+bg+$",
+            true
+        );
+        // the middle row should have an unshaded band within the viewport marker
+        centerMatcher = ImagePatternMatching.rowMatch(
+            paintedSlippyMap,
+            paintedSlippyMap.getHeight()/2,
+            paletteMap,
+            "^(d+bq+)(v+)(q+bd+)$",
+            true
+        );
+        // the topmost and bottommost rows should have an unshaded band
+        Matcher topMatcher = ImagePatternMatching.rowMatch(
+            paintedSlippyMap,
+            0,
+            paletteMap,
+            "^(d+)(g+)(d+)$",
+            true
+        );
+        Matcher BottomMatcher = ImagePatternMatching.rowMatch(
+            paintedSlippyMap,
+            paintedSlippyMap.getHeight()-1,
+            paletteMap,
+            "^(d+)(g+)(d+)$",
+            true
+        );
+        // the three rows should have the unshaded band in the same place
+        assertEquals(centerMatcher.group(1).length(), topMatcher.group(1).length());
+        assertEquals(centerMatcher.group(1).length(), BottomMatcher.group(1).length());
+        assertEquals(centerMatcher.group(2).length(), topMatcher.group(2).length());
+        assertEquals(centerMatcher.group(2).length(), BottomMatcher.group(2).length());
+
+        // deleting dataLayerA should hopefully switch our active layer back to dataLayerB
+        MainApplication.getLayerManager().removeLayer(dataLayerA);
+        this.paintSlippyMap();
+
+        // now we're really just repeating the same assertions we made originally when dataLayerB was active
+        // the middle row should be entirely unshaded
+        ImagePatternMatching.rowMatch(
+            paintedSlippyMap,
+            paintedSlippyMap.getHeight()/2,
+            paletteMap,
+            "^g+bv+bg+$",
+            true
+        );
+        // the middle column should have an unshaded band within the viewport marker
+        centerMatcher = ImagePatternMatching.columnMatch(
+            paintedSlippyMap,
+            paintedSlippyMap.getWidth()/2,
+            paletteMap,
+            "^(d+bq+)(v+)(q+bd+)$",
+            true
+        );
+        // the leftmost and rightmost columns should have an unshaded band
+        leftMatcher = ImagePatternMatching.columnMatch(
+            paintedSlippyMap,
+            0,
+            paletteMap,
+            "^(d+)(g+)(d+)$",
+            true
+        );
+        rightMatcher = ImagePatternMatching.columnMatch(
+            paintedSlippyMap,
+            paintedSlippyMap.getWidth()-1,
+            paletteMap,
+            "^(d+)(g+)(d+)$",
+            true
+        );
+        // the three columns should have the unshaded band in the same place
+        assertEquals(centerMatcher.group(1).length(), leftMatcher.group(1).length());
+        assertEquals(centerMatcher.group(1).length(), rightMatcher.group(1).length());
+        assertEquals(centerMatcher.group(2).length(), leftMatcher.group(2).length());
+        assertEquals(centerMatcher.group(2).length(), rightMatcher.group(2).length());
+
+        // but now if we expand its downloaded area to cover most of the southern hemisphere...
+        dataSetB.addDataSource(new DataSource(new Bounds(-75., -100., 0., 100.), "Everywhere"));
+        this.paintSlippyMap();
+
+        // we should see it all as unshaded.
+        ImagePatternMatching.rowMatch(
+            paintedSlippyMap,
+            0,
+            paletteMap,
+            "^g+$",
+            true
+        );
+        ImagePatternMatching.rowMatch(
+            paintedSlippyMap,
+            paintedSlippyMap.getHeight()/2,
+            paletteMap,
+            "^g+bv+bg+$",
+            true
+        );
+        ImagePatternMatching.rowMatch(
+            paintedSlippyMap,
+            paintedSlippyMap.getHeight()-1,
+            paletteMap,
+            "^g+$",
+            true
+        );
+        ImagePatternMatching.columnMatch(
+            paintedSlippyMap,
+            0,
+            paletteMap,
+            "^g+$",
+            true
+        );
+        ImagePatternMatching.columnMatch(
+            paintedSlippyMap,
+            paintedSlippyMap.getWidth()/2,
+            paletteMap,
+            "^g+bv+bg+$",
+            true
+        );
+        ImagePatternMatching.columnMatch(
+            paintedSlippyMap,
+            paintedSlippyMap.getWidth()-1,
+            paletteMap,
+            "^g+$",
+            true
+        );
+    }
 }

trunk/test/unit/org/openstreetmap/josm/gui/io/AsynchronousUploadPrimitivesTaskTest.java

@@ -3 +3 @@
 
 import java.util.Optional;
+
+import javax.swing.JOptionPane;
 
 import org.junit.After;
@@ -18 +20 @@
 import org.openstreetmap.josm.io.UploadStrategySpecification;
 import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.openstreetmap.josm.testutils.mockers.JOptionPaneSimpleMocker;
+
+import com.google.common.collect.ImmutableMap;
 
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
@@ -37 +42 @@
     @Rule
     @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD")
-    public JOSMTestRules test = new JOSMTestRules();
+    public JOSMTestRules test = new JOSMTestRules().assertionsInEDT();
 
+    /**
+     * Bootstrap.
+     */
     @Before
     public void bootStrap() {
+        new JOptionPaneSimpleMocker(ImmutableMap.of(
+            "A background upload is already in progress. Kindly wait for it to finish before uploading new changes", JOptionPane.OK_OPTION
+        ));
+
         DataSet dataSet = new DataSet();
         Node node1 = new Node();
@@ -60 +72 @@
     }
 
+    /**
+     * Tear down.
+     */
     @After
     public void tearDown() {
@@ -70 +85 @@
     }
 
+    /**
+     * Test single upload instance.
+     */
     @Test
     public void testSingleUploadInstance() {

trunk/test/unit/org/openstreetmap/josm/gui/preferences/advanced/ExportProfileActionTest.java

@@ -2 +2 @@
 package org.openstreetmap.josm.gui.preferences.advanced;
 
-import org.junit.BeforeClass;
+import javax.swing.JOptionPane;
+
+import org.junit.Rule;
 import org.junit.Test;
-import org.openstreetmap.josm.JOSMFixture;
 import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.openstreetmap.josm.testutils.mockers.JOptionPaneSimpleMocker;
+
+import com.google.common.collect.ImmutableMap;
+
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 
 /**
@@ -11 +18 @@
  */
 public class ExportProfileActionTest {
-
     /**
-     * Setup test.
+     * Setup tests
      */
-    @BeforeClass
-    public static void setUpBeforeClass() {
-        JOSMFixture.createUnitTestFixture().init();
-    }
+    @Rule
+    @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD")
+    public JOSMTestRules test = new JOSMTestRules().preferences().assertionsInEDT();
 
     /**
@@ -25 +30 @@
     @Test
     public void testAction() {
+        new JOptionPaneSimpleMocker(ImmutableMap.of(
+            "All the preferences of this group are default, nothing to save", JOptionPane.OK_OPTION
+        ));
         new ExportProfileAction(Main.pref, "foo", "bar").actionPerformed(null);
         new ExportProfileAction(Main.pref, "expert", "expert").actionPerformed(null);

trunk/test/unit/org/openstreetmap/josm/gui/preferences/advanced/PreferencesTableTest.java

@@ -9 +9 @@
 import java.util.Arrays;
 
-import org.junit.BeforeClass;
+import javax.swing.JOptionPane;
+
+import org.junit.Rule;
 import org.junit.Test;
-import org.openstreetmap.josm.JOSMFixture;
+import org.openstreetmap.josm.gui.ExtendedDialog;
+import org.openstreetmap.josm.gui.preferences.advanced.PreferencesTable.AllSettingsTableModel;
 import org.openstreetmap.josm.spi.preferences.StringSetting;
-import org.openstreetmap.josm.gui.preferences.advanced.PreferencesTable.AllSettingsTableModel;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.openstreetmap.josm.testutils.mockers.ExtendedDialogMocker;
+import org.openstreetmap.josm.testutils.mockers.JOptionPaneSimpleMocker;
+
+import com.google.common.collect.ImmutableMap;
+
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 
 /**
@@ -19 +28 @@
  */
 public class PreferencesTableTest {
-
     /**
-     * Setup test.
+     * Setup tests
      */
-    @BeforeClass
-    public static void setUpBeforeClass() {
-        JOSMFixture.createUnitTestFixture().init();
-    }
+    @Rule
+    @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD")
+    public JOSMTestRules test = new JOSMTestRules().preferences().assertionsInEDT();
 
     private static PrefEntry newPrefEntry(String value) {
@@ -43 +50 @@
     @Test
     public void testPreferencesTable() {
+        new JOptionPaneSimpleMocker(ImmutableMap.of(
+            "Please select the row to edit.", JOptionPane.OK_OPTION,
+            "Please select the row to delete.", JOptionPane.OK_OPTION
+        ));
+        new ExtendedDialogMocker() {
+            @Override
+            protected int getMockResult(final ExtendedDialog instance) {
+                if (instance.getTitle().equals("Add setting")) {
+                    return 1 + this.getButtonPositionFromLabel(instance, "Cancel");
+                } else {
+                    return super.getMockResult(instance);
+                }
+            }
+        };
         PreferencesTable t = newTable();
         t.fireDataChanged();

trunk/test/unit/org/openstreetmap/josm/gui/preferences/plugin/PluginPreferenceTest.java

@@ -10 +10 @@
 import java.util.Collections;
 
-import org.junit.BeforeClass;
+import org.junit.Rule;
 import org.junit.Test;
-import org.openstreetmap.josm.JOSMFixture;
 import org.openstreetmap.josm.TestUtils;
 import org.openstreetmap.josm.gui.preferences.PreferencesTestUtils;
@@ -19 +18 @@
 import org.openstreetmap.josm.plugins.PluginException;
 import org.openstreetmap.josm.plugins.PluginInformation;
+import org.openstreetmap.josm.testutils.mockers.HelpAwareOptionPaneMocker;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+
+import com.google.common.collect.ImmutableMap;
+
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 
 /**
@@ -24 +29 @@
  */
 public class PluginPreferenceTest {
-
     /**
      * Setup test.
      */
-    @BeforeClass
-    public static void setUpBeforeClass() {
-        JOSMFixture.createUnitTestFixture().init();
-    }
+    @Rule
+    @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD")
+    public JOSMTestRules test = new JOSMTestRules().preferences().assertionsInEDT().platform();
 
     /**
@@ -48 +51 @@
     public static PluginInformation getDummyPluginInformation() throws PluginException {
         return new PluginInformation(
-                new File(TestUtils.getTestDataRoot() + "plugin/dummy_plugin.jar"), "dummy_plugin");
+                new File(TestUtils.getTestDataRoot() + "__files/plugin/dummy_plugin.v31772.jar"), "dummy_plugin");
     }
 
@@ -89 +92 @@
     @Test
     public void testNotifyDownloadResults() {
+        new HelpAwareOptionPaneMocker(ImmutableMap.<String, Object>builder()
+            .put("<html></html>", "OK")  // (buildDownloadSummary() output was empty)
+            .put("<html>Please restart JOSM to activate the downloaded plugins.</html>", "OK")
+            .build()
+        );
+
         PluginDownloadTask task = new PluginDownloadTask(NullProgressMonitor.INSTANCE, Collections.<PluginInformation>emptyList(), "");
         PluginPreference.notifyDownloadResults(null, task, false);

trunk/test/unit/org/openstreetmap/josm/testutils/JOSMTestRules.java

@@ -3 +3 @@
 
 import java.awt.Color;
+import java.awt.Window;
+import java.awt.event.WindowEvent;
 import java.io.ByteArrayInputStream;
 import java.io.File;
@@ -8 +10 @@
 import java.security.GeneralSecurityException;
 import java.text.MessageFormat;
+import java.util.Arrays;
+import java.util.Map;
 import java.util.TimeZone;
+import java.util.logging.Handler;
 
 import org.junit.rules.TemporaryFolder;
@@ -37 +42 @@
 import org.openstreetmap.josm.io.OsmTransferCanceledException;
 import org.openstreetmap.josm.spi.preferences.Config;
+import org.openstreetmap.josm.spi.preferences.Setting;
+import org.openstreetmap.josm.testutils.mockers.EDTAssertionMocker;
+import org.openstreetmap.josm.testutils.mockers.WindowlessMapViewStateMocker;
+import org.openstreetmap.josm.testutils.mockers.WindowlessNavigatableComponentMocker;
 import org.openstreetmap.josm.tools.I18n;
 import org.openstreetmap.josm.tools.JosmRuntimeException;
@@ -44 +53 @@
 import org.openstreetmap.josm.tools.Territories;
 import org.openstreetmap.josm.tools.date.DateUtils;
+
+import org.awaitility.Awaitility;
 
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
@@ -64 +75 @@
     private String assumeRevisionString;
     private Version originalVersion;
+    private Runnable mapViewStateMockingRunnable;
+    private Runnable navigableComponentMockingRunnable;
+    private Runnable edtAssertionMockingRunnable;
     private boolean platform;
     private boolean useProjection;
@@ -256 +270 @@
         territories();
         rlTraffic = true;
+        return this;
+    }
+
+    /**
+     * Re-raise AssertionErrors thrown in the EDT where they would have normally been swallowed.
+     * @return this instance, for easy chaining
+     */
+    public JOSMTestRules assertionsInEDT() {
+        return this.assertionsInEDT(EDTAssertionMocker::new);
+    }
+
+    /**
+     * Re-raise AssertionErrors thrown in the EDT where they would have normally been swallowed.
+     * @param edtAssertionMockingRunnable Runnable for initializing this functionality
+     *
+     * @return this instance, for easy chaining
+     */
+    public JOSMTestRules assertionsInEDT(final Runnable edtAssertionMockingRunnable) {
+        this.edtAssertionMockingRunnable = edtAssertionMockingRunnable;
         return this;
     }
@@ -297 +330 @@
      */
     public JOSMTestRules main() {
+        return this.main(
+            WindowlessMapViewStateMocker::new,
+            WindowlessNavigatableComponentMocker::new
+        );
+    }
+
+    /**
+     * Use the {@link Main#main}, {@code Main.contentPanePrivate}, {@code Main.mainPanel},
+     *         global variables in this test.
+     * @param mapViewStateMockingRunnable Runnable to use for mocking out any required parts of
+     *        {@link org.openstreetmap.josm.gui.MapViewState}, null to skip.
+     * @param navigableComponentMockingRunnable Runnable to use for mocking out any required parts
+     *        of {@link org.openstreetmap.josm.gui.NavigatableComponent}, null to skip.
+     *
+     * @return this instance, for easy chaining
+     */
+    public JOSMTestRules main(
+        final Runnable mapViewStateMockingRunnable,
+        final Runnable navigableComponentMockingRunnable
+    ) {
         platform();
-        main = true;
+        this.main = true;
+        this.mapViewStateMockingRunnable = mapViewStateMockingRunnable;
+        this.navigableComponentMockingRunnable = navigableComponentMockingRunnable;
         return this;
     }
@@ -344 +399 @@
      */
     protected void before() throws InitializationError, ReflectiveOperationException {
-        // Tests are running headless by default.
-        System.setProperty("java.awt.headless", "true");
-
         cleanUpFromJosmFixture();
 
@@ -355 +407 @@
         }
 
+        // Add JOSM home
+        if (josmHome != null) {
+            try {
+                File home = josmHome.newFolder();
+                System.setProperty("josm.home", home.getAbsolutePath());
+                JosmBaseDirectories.getInstance().clearMemos();
+            } catch (IOException e) {
+                throw new InitializationError(e);
+            }
+        }
+
         Config.setPreferencesInstance(Main.pref);
         Config.setBaseDirectoriesProvider(JosmBaseDirectories.getInstance());
         // All tests use the same timezone.
         TimeZone.setDefault(DateUtils.UTC);
+
+        // Force log handers to reacquire reference to (junit's fake) stdout/stderr
+        for (Handler handler : Logging.getLogger().getHandlers()) {
+            if (handler instanceof Logging.ReacquiringConsoleHandler) {
+                handler.flush();
+                ((Logging.ReacquiringConsoleHandler) handler).reacquireOutputStream();
+            }
+        }
         // Set log level to info
         Logging.setLogLevel(Logging.LEVEL_INFO);
+
         // Assume anonymous user
         UserIdentityManager.getInstance().setAnonymous();
@@ -373 +445 @@
         }
 
-        // Add JOSM home
-        if (josmHome != null) {
-            try {
-                File home = josmHome.newFolder();
-                System.setProperty("josm.home", home.getAbsolutePath());
-            } catch (IOException e) {
-                throw new InitializationError(e);
-            }
-        }
-
         // Add preferences
         if (usePreferences) {
+            @SuppressWarnings("unchecked")
+            final Map<String, Setting<?>> defaultsMap = (Map<String, Setting<?>>) TestUtils.getPrivateField(Main.pref, "defaultsMap");
+            defaultsMap.clear();
             Main.pref.resetToInitialState();
             Main.pref.enableSaveOnPut(false);
@@ -448 +513 @@
         }
 
+        if (this.edtAssertionMockingRunnable != null) {
+            this.edtAssertionMockingRunnable.run();
+        }
+
         if (commands) {
             // TODO: Implement a more selective version of this once Main is restructured.
@@ -453 +522 @@
         } else {
             if (main) {
+                // apply mockers to MapViewState and NavigableComponent whether we're headless or not
+                // as we generally don't create the josm main window even in non-headless mode.
+                if (this.mapViewStateMockingRunnable != null) {
+                    this.mapViewStateMockingRunnable.run();
+                }
+                if (this.navigableComponentMockingRunnable != null) {
+                    this.navigableComponentMockingRunnable.run();
+                }
+
                 new MainApplication();
                 JOSMFixture.initContentPane();
@@ -500 +578 @@
     protected void after() throws ReflectiveOperationException {
         // Sync AWT Thread
-        GuiHelper.runInEDTAndWait(new Runnable() {
-            @Override
-            public void run() {
-            }
-        });
+        GuiHelper.runInEDTAndWait(() -> { });
+        // Sync worker thread
+        final boolean[] queueEmpty = {false};
+        MainApplication.worker.submit(() -> queueEmpty[0] = true);
+        Awaitility.await().forever().until(() -> queueEmpty[0]);
         // Remove all layers
         cleanLayerEnvironment();
@@ -517 +595 @@
             TestUtils.setPrivateStaticField(Version.class, "instance", this.originalVersion);
         }
+
+        Window[] windows = Window.getWindows();
+        if (windows.length != 0) {
+            Logging.info(
+                "Attempting to close {0} windows left open by tests: {1}",
+                windows.length,
+                Arrays.toString(windows)
+            );
+        }
+        GuiHelper.runInEDTAndWait(() -> {
+            for (Window window : windows) {
+                window.dispatchEvent(new WindowEvent(window, WindowEvent.WINDOW_CLOSING));
+                window.dispose();
+            }
+        });
 
         // Parts of JOSM uses weak references - destroy them.
@@ -570 +663 @@
                     throw exception;
                 } else {
+                    Logging.debug("Thread state at timeout: {0}", Thread.getAllStackTraces());
                     throw new Exception(MessageFormat.format("Test timed out after {0}ms", timeout));
                 }