Ignore:
Timestamp:
2015-06-20T23:42:21+02:00 (6 years ago)
Author:
Don-vip
Message:

checkstyle: enable relevant whitespace checks and fix them

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/test/unit/org/openstreetmap/josm/data/osm/ChangesetCacheTest.groovy

    r7938 r8510  
    22package org.openstreetmap.josm.data.osm;
    33
    4 import java.net.InetAddress.Cache;
    5 import org.junit.Test
     4import static org.junit.Assert.*
     5
     6import org.junit.Test
     7
     8class ChangesetCacheTest {
     9
     10    @Test
     11    public void test_Constructor() {
     12        ChangesetCache cache = ChangesetCache.getInstance()
     13        assert cache != null
     14    }
     15
     16    @Test
     17    public void test_addAndRemoveListeners() {
     18        ChangesetCache cache = ChangesetCache.getInstance()
     19        cache.clear()
     20
     21        // should work
     22        cache.addChangesetCacheListener null
     23
     24        // should work
     25        def listener = new ChangesetCacheListener() {
     26            public void changesetCacheUpdated(ChangesetCacheEvent event) {}
     27        }
     28        cache.addChangesetCacheListener listener
     29        // adding a second time - should work too
     30        cache.addChangesetCacheListener listener
     31        assert cache.@listeners.size() == 1 // ... but only added once
     32
     33        cache.removeChangesetCacheListener null
     34
     35        cache.removeChangesetCacheListener listener
     36        assert cache.@listeners.size() == 0
     37    }
     38
     39    @Test
     40    public void update_get_remove_cycle() {
     41        ChangesetCache cache = ChangesetCache.getInstance()
     42        cache.clear()
     43
     44        cache.update new Changeset(1)
     45        assert cache.size() == 1
     46        assert cache.get(1) != null
     47        assert cache.get(1).id == 1
     48        cache.remove(1)
     49        assert cache.size() == 0
     50    }
     51
     52    @Test
     53    public void updateTwice() {
     54        ChangesetCache cache = ChangesetCache.getInstance()
     55        cache.clear()
     56
     57        Changeset cs = new Changeset(1)
     58        cs.incomplete = false
     59        cs.put "key1", "value1"
     60        cs.open = true
     61        cache.update cs
     62
     63        Changeset cs2 = new Changeset(cs)
     64        assert cs2 != null
     65        cs2.put "key2", "value2"
     66        cs2.open = false
     67        cache.update(cs2)
     68
     69        assert cache.size() == 1
     70        assert cache.get(1) != null
     71
     72        cs = cache.get(1)
     73        assert cs.get("key1") == "value1"
     74        assert cs.get("key2") == "value2"
     75        assert !cs.open
     76    }
    677
    778
    8 import static org.junit.Assert.*;
     79    @Test
     80    public void contains() {
     81        ChangesetCache cache = ChangesetCache.getInstance()
     82        cache.@listeners.clear()
     83        cache.clear()
    984
    10 class ChangesetCacheTest {
    11        
    12         @Test
    13         public void test_Constructor() {
    14             ChangesetCache cache = ChangesetCache.getInstance()
    15                 assert cache != null
    16         }
    17        
    18         @Test
    19         public void test_addAndRemoveListeners() {
    20                 ChangesetCache cache = ChangesetCache.getInstance()
    21                 cache.clear()
    22                
    23                 // should work
    24                 cache.addChangesetCacheListener null
    25                
    26                 // should work
    27                 def listener = new ChangesetCacheListener() {
    28                         public void changesetCacheUpdated(ChangesetCacheEvent event) {}
    29                 }               
    30                 cache.addChangesetCacheListener listener
    31                 // adding a second time - should work too
    32                 cache.addChangesetCacheListener listener
    33                 assert cache.@listeners.size() == 1 // ... but only added once
    34                
    35                 cache.removeChangesetCacheListener null
    36                
    37                 cache.removeChangesetCacheListener listener
    38                 assert cache.@listeners.size() == 0
    39         }
    40        
    41         @Test
    42         public void update_get_remove_cycle() {
    43                 ChangesetCache cache = ChangesetCache.getInstance()
    44                 cache.clear()
    45                
    46                 cache.update new Changeset(1)
    47                 assert cache.size() == 1
    48                 assert cache.get(1) != null
    49                 assert cache.get(1).id == 1
    50                 cache.remove(1)
    51                 assert cache.size() == 0
    52         }
    53        
    54         @Test
    55         public void updateTwice() {
    56                 ChangesetCache cache = ChangesetCache.getInstance()
    57                 cache.clear()
    5885
    59                 Changeset cs = new Changeset(1)
    60                 cs.incomplete = false
    61                 cs.put "key1", "value1"
    62                 cs.open = true
    63                 cache.update cs
    64                
    65                 Changeset cs2 = new Changeset(cs)
    66                 assert cs2 != null
    67                 cs2.put "key2", "value2"
    68                 cs2.open = false
    69                 cache.update(cs2)
    70                
    71                 assert cache.size() == 1
    72                 assert cache.get(1) != null
    73                
    74                 cs = cache.get(1)
    75                 assert cs.get("key1") == "value1"
    76                 assert cs.get("key2") == "value2"
    77                 assert !cs.open         
    78         }
    79        
    80        
    81         @Test
    82         public void contains() {
    83                 ChangesetCache cache = ChangesetCache.getInstance()
    84                 cache.@listeners.clear()
    85                 cache.clear()
    86                
    87                
    88                 Changeset cs = new Changeset(1)
    89                 cache.update cs
    90                
    91                 assert cache.contains(1)
    92                 assert cache.contains(cs)
    93                 assert cache.contains(new Changeset(cs))
    94                
    95                 assert ! cache.contains(2)
    96                 assert ! cache.contains(new Changeset(2))
    97                 assert ! cache.contains(null)
    98         }
    99        
    100         @Test
    101         public void fireingEvents_AddAChangeset() {
    102                 ChangesetCache cache = ChangesetCache.getInstance()
    103                 cache.clear()
    104                 cache.@listeners.clear()
    105                
    106                 // should work
    107                 def listener = new ChangesetCacheListener() {
    108                                         public void changesetCacheUpdated(ChangesetCacheEvent event) {
    109                                             assert event != null
    110                                                 assert event.getAddedChangesets().size() == 1
    111                                                 assert event.getRemovedChangesets().empty
    112                                                 assert event.getUpdatedChangesets().empty
    113                                                 assert event.getSource() == cache
    114                                         }
    115                 }   
    116                 cache.addChangesetCacheListener listener
    117                 cache.update(new Changeset(1))
    118                 cache.removeChangesetCacheListener listener
    119         }
    120        
    121         @Test
    122         public void fireingEvents_UpdateChangeset() {
    123                 ChangesetCache cache = ChangesetCache.getInstance()
    124                 cache.clear()
    125                 cache.@listeners.clear()
    126                
    127                 // should work
    128                 def listener = new ChangesetCacheListener() {
    129                                         public void changesetCacheUpdated(ChangesetCacheEvent event) {
    130                                                 assert event != null
    131                                                 assert event.getAddedChangesets().empty
    132                                                 assert event.getRemovedChangesets().empty
    133                                                 assert event.getUpdatedChangesets().size() == 1
    134                                                 assert event.getSource() == cache
    135                                         }
    136                                 }   
    137                 cache.update(new Changeset(1))
    138                
    139                 cache.addChangesetCacheListener listener
    140                 cache.update(new Changeset(1))
    141                 cache.removeChangesetCacheListener listener
    142         }
    143        
    144         @Test
    145         public void fireingEvents_RemoveChangeset() {
    146                 ChangesetCache cache = ChangesetCache.getInstance()
    147                 cache.clear()
    148                 cache.@listeners.clear()
    149                
    150                 // should work
    151                 def listener = new ChangesetCacheListener() {
    152                                         public void changesetCacheUpdated(ChangesetCacheEvent event) {
    153                                                 assert event != null
    154                                                 assert event.getAddedChangesets().empty
    155                                                 assert event.getRemovedChangesets().size() == 1
    156                                                 assert event.getUpdatedChangesets().empty
    157                                                 assert event.getSource() == cache
    158                                         }
    159                                 }   
    160                 cache.update(new Changeset(1))
    161                
    162                 cache.addChangesetCacheListener listener
    163                 cache.remove 1
    164                 cache.removeChangesetCacheListener listener
    165         }
    166        
     86        Changeset cs = new Changeset(1)
     87        cache.update cs
     88
     89        assert cache.contains(1)
     90        assert cache.contains(cs)
     91        assert cache.contains(new Changeset(cs))
     92
     93        assert ! cache.contains(2)
     94        assert ! cache.contains(new Changeset(2))
     95        assert ! cache.contains(null)
     96    }
     97
     98    @Test
     99    public void fireingEvents_AddAChangeset() {
     100        ChangesetCache cache = ChangesetCache.getInstance()
     101        cache.clear()
     102        cache.@listeners.clear()
     103
     104        // should work
     105        def listener = new ChangesetCacheListener() {
     106                    public void changesetCacheUpdated(ChangesetCacheEvent event) {
     107                        assert event != null
     108                        assert event.getAddedChangesets().size() == 1
     109                        assert event.getRemovedChangesets().empty
     110                        assert event.getUpdatedChangesets().empty
     111                        assert event.getSource() == cache
     112                    }
     113        }
     114        cache.addChangesetCacheListener listener
     115        cache.update(new Changeset(1))
     116        cache.removeChangesetCacheListener listener
     117    }
     118
     119    @Test
     120    public void fireingEvents_UpdateChangeset() {
     121        ChangesetCache cache = ChangesetCache.getInstance()
     122        cache.clear()
     123        cache.@listeners.clear()
     124
     125        // should work
     126        def listener = new ChangesetCacheListener() {
     127                    public void changesetCacheUpdated(ChangesetCacheEvent event) {
     128                        assert event != null
     129                        assert event.getAddedChangesets().empty
     130                        assert event.getRemovedChangesets().empty
     131                        assert event.getUpdatedChangesets().size() == 1
     132                        assert event.getSource() == cache
     133                    }
     134                }
     135        cache.update(new Changeset(1))
     136
     137        cache.addChangesetCacheListener listener
     138        cache.update(new Changeset(1))
     139        cache.removeChangesetCacheListener listener
     140    }
     141
     142    @Test
     143    public void fireingEvents_RemoveChangeset() {
     144        ChangesetCache cache = ChangesetCache.getInstance()
     145        cache.clear()
     146        cache.@listeners.clear()
     147
     148        // should work
     149        def listener = new ChangesetCacheListener() {
     150                    public void changesetCacheUpdated(ChangesetCacheEvent event) {
     151                        assert event != null
     152                        assert event.getAddedChangesets().empty
     153                        assert event.getRemovedChangesets().size() == 1
     154                        assert event.getUpdatedChangesets().empty
     155                        assert event.getSource() == cache
     156                    }
     157                }
     158        cache.update(new Changeset(1))
     159
     160        cache.addChangesetCacheListener listener
     161        cache.remove 1
     162        cache.removeChangesetCacheListener listener
     163    }
    167164}
Note: See TracChangeset for help on using the changeset viewer.