Changeset 10444 in josm


Ignore:
Timestamp:
2016-06-21T00:05:47+02:00 (5 years ago)
Author:
Don-vip
Message:

fix #13018 - Use new test rules for AutosaveTaskTest, increase coverage (patch by michael2402) - gsoc-core

Location:
trunk
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/data/AutosaveTask.java

    r10386 r10444  
    2424import java.util.Timer;
    2525import java.util.TimerTask;
     26import java.util.concurrent.ExecutionException;
     27import java.util.concurrent.Future;
    2628import java.util.regex.Pattern;
    2729
     
    108110    }
    109111
     112    /**
     113     * Starts the autosave background task.
     114     */
    110115    public void schedule() {
    111116        if (PROP_INTERVAL.get() > 0) {
     
    129134            timer = new Timer(true);
    130135            timer.schedule(this, 1000L, PROP_INTERVAL.get() * 1000L);
    131             Main.getLayerManager().addLayerChangeListener(this);
    132             if (Main.isDisplayingMapView()) {
    133                 for (OsmDataLayer l: Main.getLayerManager().getLayersOfType(OsmDataLayer.class)) {
    134                     registerNewlayer(l);
    135                 }
    136             }
     136            Main.getLayerManager().addLayerChangeListener(this, true);
    137137        }
    138138    }
     
    357357    }
    358358
    359     public void recoverUnsavedLayers() {
     359    /**
     360     * Recover the unsaved layers and open them asynchronously.
     361     * @return A future that can be used to wait for the completion of this task.
     362     */
     363    public Future<?> recoverUnsavedLayers() {
    360364        List<File> files = getUnsavedLayersFiles();
    361365        final OpenFileTask openFileTsk = new OpenFileTask(files, null, tr("Restoring files"));
    362         Main.worker.submit(openFileTsk);
    363         Main.worker.submit(new Runnable() {
     366        final Future<?> openFilesFuture = Main.worker.submit(openFileTsk);
     367        return Main.worker.submit(new Runnable() {
    364368            @Override
    365369            public void run() {
    366                 for (File f: openFileTsk.getSuccessfullyOpenedFiles()) {
    367                     moveToDeletedLayersFolder(f);
     370                try {
     371                    // Wait for opened tasks to be generated.
     372                    openFilesFuture.get();
     373                    for (File f: openFileTsk.getSuccessfullyOpenedFiles()) {
     374                        moveToDeletedLayersFolder(f);
     375                    }
     376                } catch (InterruptedException | ExecutionException e) {
     377                    Main.error(e);
    368378                }
    369379            }
     
    406416    }
    407417
     418    /**
     419     * Mark all unsaved layers as deleted. They are still preserved in the deleted layers folder.
     420     */
    408421    public void discardUnsavedLayers() {
    409422        for (File f: getUnsavedLayersFiles()) {
  • trunk/src/org/openstreetmap/josm/gui/MainApplication.java

    r10442 r10444  
    410410        final MainFrame mainFrame = new MainFrame(contentPanePrivate, mainPanel, geometry);
    411411        Main.parent = mainFrame;
     412        mainPanel.reAddListeners();
    412413
    413414        if (args.containsKey(Option.LOAD_PREFERENCES)) {
  • trunk/src/org/openstreetmap/josm/gui/MainPanel.java

    r10432 r10444  
    4141        super(new BorderLayout());
    4242        this.layerManager = layerManager;
    43         reAddListeners();
    4443    }
    4544
  • trunk/test/unit/org/openstreetmap/josm/data/AutosaveTaskTest.java

    r10301 r10444  
    99
    1010import java.io.File;
     11import java.io.FileWriter;
     12import java.io.FilenameFilter;
    1113import java.io.IOException;
    1214import java.nio.file.Files;
    1315import java.nio.file.Paths;
    14 import java.util.ArrayList;
    1516import java.util.Calendar;
    1617import java.util.Date;
    1718import java.util.List;
    18 
    19 import org.junit.BeforeClass;
     19import java.util.concurrent.ExecutionException;
     20
     21import org.junit.Before;
     22import org.junit.Rule;
    2023import org.junit.Test;
    21 import org.openstreetmap.josm.JOSMFixture;
     24import org.openstreetmap.josm.Main;
    2225import org.openstreetmap.josm.data.AutosaveTask.AutosaveLayerInfo;
     26import org.openstreetmap.josm.data.coor.LatLon;
    2327import org.openstreetmap.josm.data.osm.DataSet;
     28import org.openstreetmap.josm.data.osm.Node;
    2429import org.openstreetmap.josm.gui.layer.OsmDataLayer;
     30import org.openstreetmap.josm.testutils.JOSMTestRules;
     31
     32import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
    2533
    2634/**
     
    2836 */
    2937public class AutosaveTaskTest {
    30 
    31     private static AutosaveTask task;
     38    /**
     39     * We need preferences and a home directory for this.
     40     */
     41    @Rule
     42    @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD")
     43    public JOSMTestRules test = new JOSMTestRules().preferences().platform().projection();
     44
     45    private AutosaveTask task;
    3246
    3347    /**
     
    3549     * @throws IOException if autosave directory cannot be created
    3650     */
    37     @BeforeClass
    38     public static void setUpBeforeClass() throws IOException {
    39         JOSMFixture.createUnitTestFixture().init();
     51    @Before
     52    public void setUp() throws IOException {
    4053        task = new AutosaveTask();
    41         Files.createDirectories(task.getAutosaveDir());
    4254    }
    4355
     
    5668    @Test
    5769    public void testGetUnsavedLayersFilesNotEmpty() throws IOException {
     70        Files.createDirectories(task.getAutosaveDir());
    5871        String autodir = task.getAutosaveDir().toString();
    5972        File layer1 = Files.createFile(Paths.get(autodir, "layer1.osm")).toFile();
    6073        File layer2 = Files.createFile(Paths.get(autodir, "layer2.osm")).toFile();
    6174        File dir = Files.createDirectory(Paths.get(autodir, "dir.osm")).toFile();
    62         try {
    63             List<File> files = task.getUnsavedLayersFiles();
    64             assertEquals(2, files.size());
    65             assertTrue(files.contains(layer1));
    66             assertTrue(files.contains(layer2));
    67             assertFalse(files.contains(dir));
    68         } finally {
    69             Files.delete(dir.toPath());
    70             Files.delete(layer2.toPath());
    71             Files.delete(layer1.toPath());
    72         }
     75        List<File> files = task.getUnsavedLayersFiles();
     76        assertEquals(2, files.size());
     77        assertTrue(files.contains(layer1));
     78        assertTrue(files.contains(layer2));
     79        assertFalse(files.contains(dir));
    7380    }
    7481
     
    7986    @Test
    8087    public void testGetNewLayerFile() throws IOException {
     88        Files.createDirectories(task.getAutosaveDir());
    8189        AutosaveLayerInfo info = new AutosaveLayerInfo(new OsmDataLayer(new DataSet(), "layer", null));
    8290        Calendar cal = Calendar.getInstance();
     
    8593        Date fixed = cal.getTime();
    8694
    87         List<File> files = new ArrayList<>();
    88 
    89         try {
    90             for (int i = 0; i <= AutosaveTask.PROP_INDEX_LIMIT.get()+1; i++) {
    91                 // Only retry 2 indexes to avoid 1000*1000 disk operations
    92                 File f = task.getNewLayerFile(info, fixed, Math.max(0, i-2));
    93                 files.add(f);
    94                 if (i > AutosaveTask.PROP_INDEX_LIMIT.get()) {
    95                     assertNull(f);
     95        for (int i = 0; i <= AutosaveTask.PROP_INDEX_LIMIT.get() + 1; i++) {
     96            // Only retry 2 indexes to avoid 1000*1000 disk operations
     97            File f = task.getNewLayerFile(info, fixed, Math.max(0, i - 2));
     98            if (i > AutosaveTask.PROP_INDEX_LIMIT.get()) {
     99                assertNull(f);
     100            } else {
     101                assertNotNull(f);
     102                File pid = task.getPidFile(f);
     103                assertTrue(pid.exists());
     104                assertTrue(f.exists());
     105                if (i == 0) {
     106                    assertEquals("null_20160101_010203456.osm", f.getName());
     107                    assertEquals("null_20160101_010203456.pid", pid.getName());
    96108                } else {
    97                     assertNotNull(f);
    98                     File pid = task.getPidFile(f);
    99                     assertTrue(pid.exists());
    100                     assertTrue(f.exists());
    101                     if (i == 0) {
    102                         assertEquals("null_20160101_010203456.osm", f.getName());
    103                         assertEquals("null_20160101_010203456.pid", pid.getName());
    104                     } else {
    105                         assertEquals("null_20160101_010203456_"+i+".osm", f.getName());
    106                         assertEquals("null_20160101_010203456_"+i+".pid", pid.getName());
    107                     }
     109                    assertEquals("null_20160101_010203456_" + i + ".osm", f.getName());
     110                    assertEquals("null_20160101_010203456_" + i + ".pid", pid.getName());
    108111                }
    109112            }
    110         } finally {
    111             for (File f : files) {
    112                 if (f != null) {
    113                     Files.delete(task.getPidFile(f).toPath());
    114                     Files.delete(f.toPath());
    115                 }
     113        }
     114    }
     115
     116    /**
     117     * Tests if {@link AutosaveTask#schedule()} creates the directories.
     118     */
     119    @Test
     120    public void testScheduleCreatesDirectories() {
     121        try {
     122            task.schedule();
     123            assertTrue(task.getAutosaveDir().toFile().isDirectory());
     124        } finally {
     125            task.cancel();
     126        }
     127    }
     128
     129    /**
     130     * Tests that {@link AutosaveTask#run()} saves every layer
     131     */
     132    @Test
     133    public void testAutosaveIgnoresUnmodifiedLayer() {
     134        OsmDataLayer layer = new OsmDataLayer(new DataSet(), "OsmData", null);
     135        Main.getLayerManager().addLayer(layer);
     136        try {
     137            task.schedule();
     138            assertEquals(0, countFiles());
     139            task.run();
     140            assertEquals(0, countFiles());
     141        } finally {
     142            task.cancel();
     143        }
     144    }
     145
     146    private int countFiles() {
     147        return task.getAutosaveDir().toFile().list(new FilenameFilter() {
     148            @Override
     149            public boolean accept(File dir, String name) {
     150                return name.endsWith(".osm");
    116151            }
    117         }
     152        }).length;
     153    }
     154
     155    /**
     156     * Tests that {@link AutosaveTask#run()} saves every layer.
     157     */
     158    @Test
     159    public void testAutosaveSavesLayer() {
     160        runAutosaveTaskSeveralTimes(1);
     161    }
     162
     163    /**
     164     * Tests that {@link AutosaveTask#run()} saves every layer.
     165     */
     166    @Test
     167    public void testAutosaveSavesLayerMultipleTimes() {
     168        AutosaveTask.PROP_FILES_PER_LAYER.put(3);
     169        runAutosaveTaskSeveralTimes(5);
     170    }
     171
     172    private void runAutosaveTaskSeveralTimes(int times) {
     173        DataSet data = new DataSet();
     174        OsmDataLayer layer = new OsmDataLayer(data, "OsmData", null);
     175        Main.getLayerManager().addLayer(layer);
     176        try {
     177            task.schedule();
     178            assertEquals(0, countFiles());
     179
     180            for (int i = 0; i < times; i++) {
     181                data.addPrimitive(new Node(new LatLon(10, 10)));
     182                task.run();
     183                assertEquals(Math.min(i + 1, 3), countFiles());
     184            }
     185
     186        } finally {
     187            task.cancel();
     188        }
     189    }
     190
     191    /**
     192     * Tests that {@link AutosaveTask#discardUnsavedLayers()} ignores layers from the current instance
     193     * @throws IOException in case of I/O error
     194     */
     195    @Test
     196    public void testDiscardUnsavedLayersIgnoresCurrentInstance() throws IOException {
     197        runAutosaveTaskSeveralTimes(1);
     198        try (FileWriter file = new FileWriter(new File(task.getAutosaveDir().toFile(), "any_other_file.osm"))) {
     199            file.append("");
     200        }
     201        assertEquals(2, countFiles());
     202
     203        task.discardUnsavedLayers();
     204        assertEquals(1, countFiles());
     205    }
     206
     207    /**
     208     * Tests that {@link AutosaveTask#run()} handles dupplicate layers
     209     * @throws InterruptedException
     210     */
     211    @Test
     212    public void testAutosaveHandlesDupplicateNames() {
     213        DataSet data1 = new DataSet();
     214        OsmDataLayer layer1 = new OsmDataLayer(data1, "OsmData", null);
     215        Main.getLayerManager().addLayer(layer1);
     216
     217        DataSet data2 = new DataSet();
     218        OsmDataLayer layer2 = new OsmDataLayer(data2, "OsmData", null);
     219
     220        try {
     221            task.schedule();
     222            assertEquals(0, countFiles());
     223            // also test adding layer later
     224            Main.getLayerManager().addLayer(layer2);
     225
     226            data1.addPrimitive(new Node(new LatLon(10, 10)));
     227            data2.addPrimitive(new Node(new LatLon(10, 10)));
     228            task.run();
     229            assertEquals(2, countFiles());
     230        } finally {
     231            task.cancel();
     232        }
     233    }
     234
     235    /**
     236     * Test that
     237     * @throws IOException
     238     * @throws ExecutionException
     239     * @throws InterruptedException
     240     */
     241    @Test
     242    public void testRecoverLayers() throws IOException, InterruptedException, ExecutionException {
     243        runAutosaveTaskSeveralTimes(1);
     244        try (FileWriter file = new FileWriter(new File(task.getAutosaveDir().toFile(), "any_other_file.osm"))) {
     245            file.append("<?xml version=\"1.0\"?><osm version=\"0.6\"><node id=\"1\" lat=\"1\" lon=\"2\" version=\"1\"/></osm>");
     246        }
     247
     248        assertEquals(2, countFiles());
     249        task.recoverUnsavedLayers().get();
     250
     251        assertEquals(1, countFiles());
    118252    }
    119253}
Note: See TracChangeset for help on using the changeset viewer.