Changeset 19695 in josm


Ignore:
Timestamp:
2026-11-20T12:53:15+01:00 (less than one hour ago)
Author:
stoecker
Message:

fix #25021 - Fix Sonar issues in VectorDataSet and added test cases - patch by DanProgs

Location:
trunk
Files:
2 edited

Legend:

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

    r19519 r19695  
    253253    @Override
    254254    public <T extends VectorPrimitive> Collection<T> getPrimitives(Predicate<? super VectorPrimitive> predicate) {
    255         Collection<VectorPrimitive> primitives = tryRead(this.readWriteLock, () -> {
     255        final Collection<VectorPrimitive> primitives = tryRead(this.readWriteLock, () -> {
    256256            final Storage<MVTTile> dataStore = this.getBestZoomDataStore().orElse(null);
    257257            final Stream<VectorDataStore> dataStoreStream = dataStore != null ? dataStore.stream().map(MVTTile::getData) : Stream.empty();
    … …  
    364364        return tryRead(this.readWriteLock, () -> {
    365365            final Storage<MVTTile> dataStore = this.getBestZoomDataStore().orElse(null);
    366             Stream<VectorDataStore> dataStoreStream = dataStore != null ? dataStore.stream().map(MVTTile::getData) : Stream.empty();
    367                 return Stream.concat(dataStoreStream, Stream.of(this.customDataStore)).map(VectorDataStore::getPrimitivesMap)
    368                   .flatMap(dataMap -> {
    369                     // Synchronize on dataMap to avoid concurrent modification errors
    370                     synchronized (dataMap) {
    371                         return this.currentSelectedPrimitives.stream().map(dataMap::get).filter(Objects::nonNull);
    372                     }
    373                 }).collect(Collectors.toList());
     366            final Stream<VectorDataStore> dataStoreStream = dataStore != null
     367                    ? dataStore.stream().map(MVTTile::getData)
     368                    : Stream.empty();
     369
     370            return Stream.concat(dataStoreStream, Stream.ofNullable(this.customDataStore))
     371                    .map(VectorDataStore::getPrimitivesMap)
     372                    .filter(Objects::nonNull)
     373                    .flatMap(dataMap -> {
     374                        final Map<PrimitiveId, VectorPrimitive> lockObject = dataMap;
     375                        synchronized (lockObject) {
     376                            final List<VectorPrimitive> selectedInMap = new ArrayList<>();
     377                            for (PrimitiveId id : this.currentSelectedPrimitives) {
     378                                final VectorPrimitive primitive = lockObject.get(id);
     379                                if (primitive != null) {
     380                                    selectedInMap.add(primitive);
     381                                }
     382                            }
     383                            return selectedInMap.stream();
     384                        }
     385                    })
     386                    .collect(Collectors.toList());
    374387        }).orElseGet(Collections::emptyList);
    375388    }
    … …  
    491504            SelectionChangeEvent<VectorPrimitive, VectorNode, VectorWay, VectorRelation, VectorDataSet>> command) {
    492505        synchronized (this.selectionLock) {
    493             SelectionChangeEvent<VectorPrimitive, VectorNode, VectorWay, VectorRelation, VectorDataSet> event =
     506            final SelectionChangeEvent<VectorPrimitive, VectorNode, VectorWay, VectorRelation, VectorDataSet> event =
    494507                    command.apply(currentSelectedPrimitives.stream().map(this::getPrimitiveById).collect(Collectors.toSet()));
    495508            if (event.isNop()) {
    … …  
    636649     */
    637650    public void setInvisibleLayers(Collection<String> invisibleLayers) {
    638         String[] currentInvisibleLayers = invisibleLayers.stream().filter(Objects::nonNull).toArray(String[]::new);
    639         List<String> temporaryList = Arrays.asList(currentInvisibleLayers);
     651        final String[] currentInvisibleLayers = invisibleLayers.stream().filter(Objects::nonNull).toArray(String[]::new);
     652        final List<String> temporaryList = Arrays.asList(currentInvisibleLayers);
    640653        this.dataStoreMap.values().stream().flatMap(Collection::stream).map(MVTTile::getData)
    641654          .forEach(dataStore -> dataStore.getAllPrimitives().parallelStream()
  • trunk/test/unit/org/openstreetmap/josm/data/vector/VectorDataSetTest.java

    r19519 r19695  
    77import java.nio.file.Paths;
    88import java.util.ArrayList;
     9import java.util.Arrays;
    910import java.util.Collection;
    1011import java.util.Collections;
    1112import java.util.HashSet;
     13import java.util.List;
     14import java.util.concurrent.CountDownLatch;
     15import java.util.concurrent.ExecutorService;
     16import java.util.concurrent.Executors;
     17import java.util.concurrent.Future;
     18import java.util.concurrent.TimeUnit;
     19import java.util.stream.Collectors;
    1220
    1321import org.awaitility.Awaitility;
    … …  
    1523import org.junit.jupiter.api.BeforeEach;
    1624import org.junit.jupiter.api.RepeatedTest;
     25import org.junit.jupiter.api.Test;
    1726import org.openstreetmap.josm.TestUtils;
     27import org.openstreetmap.josm.data.coor.LatLon;
    1828import org.openstreetmap.josm.data.imagery.ImageryInfo;
    1929import org.openstreetmap.josm.data.imagery.vectortile.mapbox.MVTTile;
    … …  
    7484        }
    7585        final MapboxVectorTileSource tileSource = layer.getTileSource();
    76         MapboxVectorCachedTileLoader tileLoader = layer.getTileLoader();
    77         Collection<MVTTile> tilesCollection = new ArrayList<>();
     86        final MapboxVectorCachedTileLoader tileLoader = layer.getTileLoader();
     87        final Collection<MVTTile> tilesCollection = new ArrayList<>();
    7888        for (int i = 0; i < tiles.length / 3; i++) {
    7989            final MVTTile tile = (MVTTile) layer.createTile(tileSource, tiles[3 * i + 1], tiles[3 * i + 2], tiles[3 * i]);
    … …  
    125135        assertEquals(0, dataSet.getRelations().size());
    126136    }
     137
     138    /**
     139     * Test that {@link VectorDataSet#getAllSelected()} returns the expected selected primitives
     140     * and returns an empty collection once the selection is cleared.
     141     */
     142    @Test
     143    void testGetAllSelected() {
     144        final VectorDataSet dataSet = this.layer.getData();
     145        assertTrue(dataSet.getAllSelected().isEmpty());
     146
     147        dataSet.setZoom(14);
     148        loadTile(this.layer, 14, 3248, 6258);
     149
     150        // Select two arbitrary nodes from the loaded tile
     151        final List<VectorNode> nodesToSelect = dataSet.getNodes().stream()
     152                .limit(2)
     153                .collect(Collectors.toList());
     154        assertEquals(2, nodesToSelect.size());
     155
     156        dataSet.setSelected(nodesToSelect);
     157
     158        final Collection<VectorPrimitive> selected = dataSet.getAllSelected();
     159        assertEquals(2, selected.size());
     160        assertTrue(selected.containsAll(nodesToSelect));
     161
     162        // Clear selection again
     163        dataSet.clearSelection();
     164        assertTrue(dataSet.getAllSelected().isEmpty());
     165    }
     166
     167    /**
     168     * Test that {@link VectorDataSet#getAllSelected()} properly combines selected primitives
     169     * from both loaded vector tiles and the custom data store.
     170     */
     171    @Test
     172    void testGetAllSelectedWithCustomDataStore() {
     173        final VectorDataSet dataSet = this.layer.getData();
     174        dataSet.setZoom(14);
     175        loadTile(this.layer, 14, 3248, 6258);
     176
     177        // Combine a primitive from the tile and a custom primitive (customDataStore)
     178        final VectorPrimitive tilePrimitive = dataSet.getNodes().iterator().next();
     179        final VectorNode customNode = new VectorNode("custom-layer");
     180        customNode.setCoor(new LatLon(0, 0));
     181        dataSet.addPrimitive(customNode);
     182
     183        dataSet.setSelected(Arrays.asList(tilePrimitive, customNode));
     184
     185        final Collection<VectorPrimitive> selected = dataSet.getAllSelected();
     186        assertEquals(2, selected.size());
     187        assertTrue(selected.contains(tilePrimitive));
     188        assertTrue(selected.contains(customNode));
     189    }
     190
     191    /**
     192     * Test that {@link VectorDataSet#getAllSelected()} is thread-safe when primitives are
     193     * concurrently added and removed while reading the current selection.
     194     *
     195     * @throws Exception if any thread execution or timeout error occurs
     196     */
     197    @Test
     198    void testGetAllSelectedThreadSafety() throws Exception {
     199        final VectorDataSet dataSet = this.layer.getData();
     200        dataSet.setZoom(14);
     201        loadTile(this.layer, 14, 3248, 6258);
     202
     203        final List<VectorNode> nodesToSelect = dataSet.getNodes().stream()
     204                .limit(5)
     205                .collect(Collectors.toList());
     206        dataSet.setSelected(nodesToSelect);
     207
     208        final int iterations = 200;
     209        final ExecutorService executor = Executors.newFixedThreadPool(2);
     210        final CountDownLatch startLatch = new CountDownLatch(1);
     211
     212        // Thread 1: Continuously add and remove primitives (modifies underlying maps)
     213        final Future<?> writer = executor.submit(() -> {
     214            startLatch.await();
     215            for (int i = 0; i < iterations; i++) {
     216                final VectorNode tempNode = new VectorNode("temp-layer");
     217                tempNode.setCoor(new LatLon(i * 0.001, i * 0.001));
     218                dataSet.addPrimitive(tempNode);
     219                dataSet.removePrimitive(tempNode);
     220            }
     221            return null;
     222        });
     223
     224        // Thread 2: Concurrently read getAllSelected()
     225        final Future<?> reader = executor.submit(() -> {
     226            startLatch.await();
     227            for (int i = 0; i < iterations; i++) {
     228                final Collection<VectorPrimitive> selected = dataSet.getAllSelected();
     229                assertEquals(5, selected.size());
     230            }
     231            return null;
     232        });
     233
     234        startLatch.countDown();
     235        writer.get(5, TimeUnit.SECONDS);
     236        reader.get(5, TimeUnit.SECONDS);
     237        executor.shutdown();
     238    }
    127239}
Note: See TracChangeset for help on using the changeset viewer.