Changeset 12747 in josm


Ignore:
Timestamp:
2017-09-06T00:44:51+02:00 (3 months ago)
Author:
Don-vip
Message:

see #15229 - see #15182 - fix unit tests

Location:
trunk
Files:
4 edited

Legend:

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

    r12743 r12747  
    4242    private final Map<Integer, Changeset> cache = new HashMap<>();
    4343
    44     private final CopyOnWriteArrayList<ChangesetCacheListener> listeners = new CopyOnWriteArrayList<>();
     44    final CopyOnWriteArrayList<ChangesetCacheListener> listeners = new CopyOnWriteArrayList<>();
    4545
    4646    /**
  • trunk/test/unit/org/openstreetmap/josm/data/UserIdentityManagerTest.java

    r12743 r12747  
    99import static org.junit.Assert.assertTrue;
    1010
    11 import org.junit.BeforeClass;
     11import org.junit.Rule;
    1212import org.junit.Test;
    13 import org.openstreetmap.josm.JOSMFixture;
    1413import org.openstreetmap.josm.Main;
    1514import org.openstreetmap.josm.data.osm.User;
    1615import org.openstreetmap.josm.data.osm.UserInfo;
     16import org.openstreetmap.josm.testutils.JOSMTestRules;
     17
     18import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
    1719
    1820/**
     
    2426     * Setup test.
    2527     */
    26     @BeforeClass
    27     public static void initTestCase() {
    28         JOSMFixture.createUnitTestFixture().init();
    29     }
     28    @Rule
     29    @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD")
     30    public JOSMTestRules test = new JOSMTestRules().preferences();
    3031
    3132    private static UserInfo newUserInfo() {
  • trunk/test/unit/org/openstreetmap/josm/data/osm/ChangesetCacheTest.java

    r12743 r12747  
    1010import java.util.Collection;
    1111import java.util.Collections;
    12 import java.util.List;
     12import java.util.concurrent.CountDownLatch;
     13import java.util.concurrent.TimeUnit;
    1314
    1415import org.junit.After;
     16import org.junit.Before;
     17import org.junit.Rule;
    1518import org.junit.Test;
    16 import org.openstreetmap.josm.TestUtils;
    1719import org.openstreetmap.josm.data.UserIdentityManager;
     20import org.openstreetmap.josm.testutils.JOSMTestRules;
     21import org.openstreetmap.josm.tools.Logging;
     22
     23import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
    1824
    1925/**
     
    2329
    2430    /**
    25      * Clears cache after each unit test.
     31     * Setup test.
     32     */
     33    @Rule
     34    @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD")
     35    public JOSMTestRules test = new JOSMTestRules();
     36
     37    private static final ChangesetCache cache = ChangesetCache.getInstance();
     38
     39    /**
     40     * Clears cache before/after each unit test.
    2641     */
    2742    @After
    28     public void after() {
    29         ChangesetCache.getInstance().clear();
     43    @Before
     44    public void clearCache() {
     45        cache.listeners.clear();
     46        cache.clear();
     47    }
     48
     49    abstract class TestListener implements ChangesetCacheListener {
     50
     51        protected final CountDownLatch latch = new CountDownLatch(1);
     52        protected ChangesetCacheEvent event;
     53
     54        @Override
     55        public void changesetCacheUpdated(ChangesetCacheEvent event) {
     56            this.event = event;
     57            latch.countDown();
     58        }
     59
     60        protected final void await() {
     61            try {
     62                latch.await(2, TimeUnit.SECONDS);
     63            } catch (InterruptedException e) {
     64                Logging.error(e);
     65            }
     66        }
     67
     68        abstract void test();
    3069    }
    3170
     
    3877    }
    3978
    40     @SuppressWarnings("unchecked")
    41     private static List<ChangesetCacheListener> getListeners(ChangesetCache cache) throws ReflectiveOperationException {
    42         return (List<ChangesetCacheListener>) TestUtils.getPrivateField(cache, "listeners");
    43     }
    44 
    45     @Test
    46     public void testAddAndRemoveListeners() throws ReflectiveOperationException {
    47         ChangesetCache cache = ChangesetCache.getInstance();
    48         cache.clear();
    49 
     79    @Test
     80    public void testAddAndRemoveListeners() {
    5081        // should work
    5182        cache.addChangesetCacheListener(null);
     
    5990        // adding a second time - should work too
    6091        cache.addChangesetCacheListener(listener);
    61         assertEquals(1, getListeners(cache).size()); // ... but only added once
     92        assertEquals(1, cache.listeners.size()); // ... but only added once
    6293
    6394        cache.removeChangesetCacheListener(null);
    6495
    6596        cache.removeChangesetCacheListener(listener);
    66         assertTrue(getListeners(cache).isEmpty());
     97        assertTrue(cache.listeners.isEmpty());
    6798    }
    6899
    69100    @Test
    70101    public void testUpdateGetRemoveCycle() {
    71         ChangesetCache cache = ChangesetCache.getInstance();
    72         cache.clear();
    73 
    74102        cache.update(new Changeset(1));
    75103        assertEquals(1, cache.size());
     
    82110    @Test
    83111    public void testUpdateTwice() {
    84         ChangesetCache cache = ChangesetCache.getInstance();
    85         cache.clear();
    86 
    87112        Changeset cs = new Changeset(1);
    88113        cs.setIncomplete(false);
     
    107132
    108133    @Test
    109     public void testContains() throws ReflectiveOperationException {
    110         ChangesetCache cache = ChangesetCache.getInstance();
    111         getListeners(cache).clear();
    112         cache.clear();
    113 
     134    public void testContains() {
    114135        Changeset cs = new Changeset(1);
    115136        cache.update(cs);
     
    125146
    126147    @Test
    127     public void testFireingEventsAddAChangeset() throws ReflectiveOperationException {
    128         ChangesetCache cache = ChangesetCache.getInstance();
    129         cache.clear();
    130         getListeners(cache).clear();
    131 
    132         // should work
    133         ChangesetCacheListener listener = new ChangesetCacheListener() {
    134             @Override
    135             public void changesetCacheUpdated(ChangesetCacheEvent event) {
     148    public void testFireingEventsAddAChangeset() {
     149        TestListener listener = new TestListener() {
     150            @Override
     151            public void test() {
     152                await();
    136153                assertNotNull(event);
    137154                assertEquals(1, event.getAddedChangesets().size());
     
    143160        cache.addChangesetCacheListener(listener);
    144161        cache.update(new Changeset(1));
     162        listener.test();
    145163        cache.removeChangesetCacheListener(listener);
    146164    }
    147165
    148166    @Test
    149     public void testFireingEventsUpdateChangeset() throws ReflectiveOperationException {
    150         ChangesetCache cache = ChangesetCache.getInstance();
    151         cache.clear();
    152         getListeners(cache).clear();
    153 
    154         // should work
    155         ChangesetCacheListener listener = new ChangesetCacheListener() {
    156             @Override
    157             public void changesetCacheUpdated(ChangesetCacheEvent event) {
     167    public void testFireingEventsUpdateChangeset() {
     168        TestListener listener = new TestListener() {
     169            @Override
     170            void test() {
     171                await();
    158172                assertNotNull(event);
    159173                assertTrue(event.getAddedChangesets().isEmpty());
     
    163177            }
    164178        };
     179        Changeset cs = new Changeset(1);
     180        cache.update(cs);
     181
     182        cache.addChangesetCacheListener(listener);
     183        cache.update(cs);
     184        listener.test();
     185        cache.removeChangesetCacheListener(listener);
     186    }
     187
     188    @Test
     189    public void testFireingEventsRemoveChangeset() {
     190        // Waiter listener to ensure the second listener does not receive the first event
     191        TestListener waiter = new TestListener() {
     192            @Override
     193            void test() {
     194                await();
     195            }
     196        };
     197        cache.addChangesetCacheListener(waiter);
    165198        cache.update(new Changeset(1));
    166 
    167         cache.addChangesetCacheListener(listener);
    168         cache.update(new Changeset(1));
    169         cache.removeChangesetCacheListener(listener);
    170     }
    171 
    172     @Test
    173     public void testFireingEventsRemoveChangeset() throws ReflectiveOperationException {
    174         ChangesetCache cache = ChangesetCache.getInstance();
    175         cache.clear();
    176         getListeners(cache).clear();
    177 
    178         // should work
    179         ChangesetCacheListener listener = new ChangesetCacheListener() {
    180             @Override
    181             public void changesetCacheUpdated(ChangesetCacheEvent event) {
     199        waiter.test();
     200        cache.removeChangesetCacheListener(waiter);
     201
     202        TestListener listener = new TestListener() {
     203            @Override
     204            void test() {
     205                await();
    182206                assertNotNull(event);
    183207                assertTrue(event.getAddedChangesets().isEmpty());
     
    187211            }
    188212        };
    189         cache.update(new Changeset(1));
    190 
    191213        cache.addChangesetCacheListener(listener);
    192214        cache.remove(1);
     215        listener.test();
    193216        cache.removeChangesetCacheListener(listener);
    194217    }
     
    199222    @Test
    200223    public void testGetOpenChangesets() {
    201         final ChangesetCache cache = ChangesetCache.getInstance();
    202224        // empty cache => empty list
    203225        assertTrue(
     
    236258    @Test
    237259    public void testGetOpenChangesetsForCurrentUser() {
    238         final ChangesetCache cache = ChangesetCache.getInstance();
    239260        // empty cache => empty list
    240261        assertTrue(
     
    271292    @Test
    272293    public void testRemove() {
    273         final ChangesetCache cache = ChangesetCache.getInstance();
    274294        Changeset cs1 = new Changeset(1);
    275295        cache.update(cs1);
  • trunk/test/unit/org/openstreetmap/josm/testutils/JOSMTestRules.java

    r12643 r12747  
    1515import org.openstreetmap.josm.JOSMFixture;
    1616import org.openstreetmap.josm.Main;
     17import org.openstreetmap.josm.data.UserIdentityManager;
    1718import org.openstreetmap.josm.data.osm.event.SelectionEventManager;
    1819import org.openstreetmap.josm.data.projection.Projections;
     
    264265        // Set log level to info
    265266        Logging.setLogLevel(Logging.LEVEL_INFO);
     267        // Assume anonymous user
     268        UserIdentityManager.getInstance().setAnonymous();
    266269
    267270        // Set up i18n
Note: See TracChangeset for help on using the changeset viewer.