Ignore:
Timestamp:
2018-08-05T20:53:19+02:00 (6 years ago)
Author:
Don-vip
Message:

drop FEST library. This project seems to have vanished years ago, and we don't use it a lot

Location:
trunk/test/unit/org/openstreetmap/josm/gui/conflict/pair
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/test/unit/org/openstreetmap/josm/gui/conflict/pair/nodes/NodeListMergeModelTest.java

    r12620 r14092  
    22package org.openstreetmap.josm.gui.conflict.pair.nodes;
    33
    4 import static org.fest.reflect.core.Reflection.field;
    5 import static org.fest.reflect.core.Reflection.method;
    64import static org.junit.Assert.assertEquals;
    75import static org.junit.Assert.assertFalse;
     
    119import java.beans.PropertyChangeEvent;
    1210import java.beans.PropertyChangeListener;
     11import java.lang.reflect.Method;
     12import java.security.AccessController;
     13import java.security.PrivilegedAction;
    1314import java.util.ArrayList;
    1415import java.util.Arrays;
     
    2021import org.junit.Rule;
    2122import org.junit.Test;
     23import org.openstreetmap.josm.TestUtils;
    2224import org.openstreetmap.josm.data.osm.Node;
    2325import org.openstreetmap.josm.data.osm.Way;
     26import org.openstreetmap.josm.gui.conflict.pair.AbstractListMergeModel;
    2427import org.openstreetmap.josm.testutils.DatasetFactory;
    2528import org.openstreetmap.josm.testutils.JOSMTestRules;
     
    4548    @SuppressWarnings("unchecked")
    4649    protected List<Node> inspectNodeList(NodeListMergeModel model, String name) {
    47         return method("get" + name + "Entries")
    48         .withReturnType(List.class)
    49         .in(model)
    50         .invoke();
     50        try {
     51            Method getNamedEntries = AbstractListMergeModel.class.getDeclaredMethod("get" + name + "Entries");
     52            AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
     53                getNamedEntries.setAccessible(true);
     54                return null;
     55            });
     56            return (List<Node>) getNamedEntries.invoke(model);
     57        } catch (ReflectiveOperationException | IllegalArgumentException | SecurityException e) {
     58            throw new RuntimeException(e);
     59        }
    5160    }
    5261
    5362    protected DefaultListSelectionModel inspectListSelectionModel(NodeListMergeModel model, String name) {
    54         return field(name).ofType(DefaultListSelectionModel.class)
    55         .in(model)
    56         .get();
     63        try {
     64            return (DefaultListSelectionModel) TestUtils.getPrivateField(AbstractListMergeModel.class, model, name);
     65        } catch (ReflectiveOperationException e) {
     66            throw new RuntimeException(e);
     67        }
     68    }
     69
     70    @SuppressWarnings("unchecked")
     71    protected Set<PropertyChangeListener> getListeners(NodeListMergeModel model) throws ReflectiveOperationException {
     72        return (Set<PropertyChangeListener>)
     73                TestUtils.getPrivateField(AbstractListMergeModel.class, model, "listeners");
    5774    }
    5875
     
    644661    @SuppressWarnings("unchecked")
    645662    @Test
    646     public void testAddPropertyChangeListener() {
    647         NodeListMergeModel model = new NodeListMergeModel();
    648 
    649         PropertyChangeListener listener = new PropertyChangeListener() {
    650 
    651             public void propertyChange(PropertyChangeEvent evt) {
    652             }
     663    public void testAddPropertyChangeListener() throws ReflectiveOperationException {
     664        NodeListMergeModel model = new NodeListMergeModel();
     665
     666        PropertyChangeListener listener = evt -> {
    653667        };
    654668
    655669        model.addPropertyChangeListener(listener);
    656670
    657         Set<PropertyChangeListener> listeners = field("listeners")
    658         .ofType(Set.class)
    659         .in(model)
    660         .get();
     671        Set<PropertyChangeListener> listeners = getListeners(model);
    661672
    662673        assertEquals(1, listeners.size());
     
    666677    @SuppressWarnings("unchecked")
    667678    @Test
    668     public void testRemovePropertyChangeListener() {
    669         NodeListMergeModel model = new NodeListMergeModel();
    670 
    671         PropertyChangeListener listener = new PropertyChangeListener() {
    672 
    673             public void propertyChange(PropertyChangeEvent evt) {
    674             }
     679    public void testRemovePropertyChangeListener() throws ReflectiveOperationException {
     680        NodeListMergeModel model = new NodeListMergeModel();
     681
     682        PropertyChangeListener listener = evt -> {
    675683        };
    676684
     
    678686        model.removePropertyChangeListener(listener);
    679687
    680         Set<PropertyChangeListener> listeners = field("listeners")
    681         .ofType(Set.class)
    682         .in(model)
    683         .get();
     688        Set<PropertyChangeListener> listeners = getListeners(model);
    684689
    685690        assertEquals(0, listeners.size());
  • trunk/test/unit/org/openstreetmap/josm/gui/conflict/pair/tags/TagMergeModelTest.java

    r10962 r14092  
    22package org.openstreetmap.josm.gui.conflict.pair.tags;
    33
    4 import static org.fest.reflect.core.Reflection.field;
    54import static org.junit.Assert.assertEquals;
    65import static org.junit.Assert.assertNull;
    76
    8 import java.beans.PropertyChangeEvent;
    97import java.beans.PropertyChangeListener;
    108import java.util.List;
     
    1311import org.junit.Rule;
    1412import org.junit.Test;
     13import org.openstreetmap.josm.TestUtils;
    1514import org.openstreetmap.josm.data.osm.Node;
    1615import org.openstreetmap.josm.gui.conflict.pair.MergeDecisionType;
     
    3231    public JOSMTestRules test = new JOSMTestRules();
    3332
    34     @Test
    35     public void testAddPropertyChangeListener() {
    36         TagMergeModel model = new TagMergeModel();
    37         PropertyChangeListener listener = new PropertyChangeListener() {
    38 
    39             public void propertyChange(PropertyChangeEvent evt) {
    40             }
     33    protected Set<PropertyChangeListener> getListeners(TagMergeModel model) throws ReflectiveOperationException {
     34        return (Set<PropertyChangeListener>) TestUtils.getPrivateField(model, "listeners");
     35    }
     36
     37    protected List<TagMergeItem> getTagMergeItems(TagMergeModel model) throws ReflectiveOperationException {
     38        return (List<TagMergeItem>) TestUtils.getPrivateField(model, "tagMergeItems");
     39    }
     40
     41    @Test
     42    public void testAddPropertyChangeListener() throws ReflectiveOperationException {
     43        TagMergeModel model = new TagMergeModel();
     44        PropertyChangeListener listener = evt -> {
    4145        };
    4246        model.addPropertyChangeListener(listener);
    4347
    44         Set<?> list = field("listeners").ofType(Set.class)
    45         .in(model)
    46         .get();
     48        Set<?> list = getListeners(model);
    4749
    4850        assertEquals(1, list.size());
     
    5153
    5254    @Test
    53     public void testRemovePropertyChangeListener() {
    54         TagMergeModel model = new TagMergeModel();
    55         PropertyChangeListener listener = new PropertyChangeListener() {
    56 
    57             public void propertyChange(PropertyChangeEvent evt) {
    58             }
     55    public void testRemovePropertyChangeListener() throws ReflectiveOperationException {
     56        TagMergeModel model = new TagMergeModel();
     57        PropertyChangeListener listener = evt -> {
    5958        };
    6059        model.addPropertyChangeListener(listener);
    6160        model.removePropertyChangeListener(listener);
    6261
    63         Set<?> list = field("listeners")
    64         .ofType(Set.class)
    65         .in(model)
    66         .get();
     62        Set<?> list = getListeners(model);
    6763
    6864        assertEquals(0, list.size());
     
    7066
    7167    @Test
    72     public void testPopulateNoConflichts() {
    73         Node my = new Node(1);
    74         Node their = new Node(1);
    75         TagMergeModel model = new TagMergeModel();
    76         model.populate(my, their);
    77 
    78         List<TagMergeItem> list = field("tagMergeItems")
    79         .ofType(List.class)
    80         .in(model)
    81         .get();
     68    public void testPopulateNoConflichts() throws ReflectiveOperationException {
     69        Node my = new Node(1);
     70        Node their = new Node(1);
     71        TagMergeModel model = new TagMergeModel();
     72        model.populate(my, their);
     73
     74        List<TagMergeItem> list = getTagMergeItems(model);
    8275
    8376        assertEquals(0, list.size());
     
    8578
    8679    @Test
    87     public void testPopulateNoConflicts1() {
     80    public void testPopulateNoConflicts1() throws ReflectiveOperationException {
    8881        Node my = new Node(1);
    8982        my.put("key", "value");
     
    9386        model.populate(my, their);
    9487
    95         List<TagMergeItem> list = field("tagMergeItems")
    96         .ofType(List.class)
    97         .in(model)
    98         .get();
     88        List<TagMergeItem> list = getTagMergeItems(model);
    9989
    10090        assertEquals(0, list.size());
     
    10292
    10393    @Test
    104     public void testPopulateMissingKeyMine() {
     94    public void testPopulateMissingKeyMine() throws ReflectiveOperationException {
    10595        Node my = new Node(1);
    10696        Node their = new Node(1);
     
    10999        model.populate(my, their);
    110100
    111         List<TagMergeItem> list = field("tagMergeItems")
    112         .ofType(List.class)
    113         .in(model)
    114         .get();
     101        List<TagMergeItem> list = getTagMergeItems(model);
    115102
    116103        assertEquals(1, list.size());
     
    123110
    124111    @Test
    125     public void testPopulateMissingKeyTheir() {
     112    public void testPopulateMissingKeyTheir() throws ReflectiveOperationException {
    126113        Node my = new Node(1);
    127114        my.put("key", "value");
     
    130117        model.populate(my, their);
    131118
    132         List<TagMergeItem> list = field("tagMergeItems")
    133         .ofType(List.class)
    134         .in(model)
    135         .get();
     119        List<TagMergeItem> list = getTagMergeItems(model);
    136120
    137121        assertEquals(1, list.size());
     
    144128
    145129    @Test
    146     public void testPopulateConflictingValues() {
     130    public void testPopulateConflictingValues() throws ReflectiveOperationException {
    147131        Node my = new Node(1);
    148132        my.put("key", "myvalue");
     
    152136        model.populate(my, their);
    153137
    154         List<TagMergeItem> list = field("tagMergeItems")
    155         .ofType(List.class)
    156         .in(model)
    157         .get();
     138        List<TagMergeItem> list = getTagMergeItems(model);
    158139
    159140        assertEquals(1, list.size());
     
    166147
    167148    @Test
    168     public void testAddItem() {
     149    public void testAddItem() throws ReflectiveOperationException {
    169150        TagMergeItem item = new TagMergeItem("key", "myvalue", "theirvalue");
    170151        TagMergeModel model = new TagMergeModel();
    171152        model.addItem(item);
    172153
    173         List<TagMergeItem> list = field("tagMergeItems")
    174         .ofType(List.class)
    175         .in(model)
    176         .get();
     154        List<TagMergeItem> list = getTagMergeItems(model);
    177155
    178156        assertEquals(1, list.size());
     
    185163
    186164    @Test
    187     public void testDecide() {
     165    public void testDecide() throws ReflectiveOperationException {
    188166        TagMergeItem item = new TagMergeItem("key", "myvalue", "theirvalue");
    189167        TagMergeModel model = new TagMergeModel();
    190168        model.addItem(item);
    191169
    192         List<TagMergeItem> list = field("tagMergeItems")
    193         .ofType(List.class)
    194         .in(model)
    195         .get();
     170        List<TagMergeItem> list = getTagMergeItems(model);
    196171
    197172        model.decide(0, MergeDecisionType.KEEP_MINE);
     
    212187
    213188    @Test
    214     public void testDecideMultiple() {
     189    public void testDecideMultiple() throws ReflectiveOperationException {
    215190
    216191        TagMergeModel model = new TagMergeModel();
     
    219194        }
    220195
    221         List<TagMergeItem> list = field("tagMergeItems")
    222         .ofType(List.class)
    223         .in(model)
    224         .get();
     196        List<TagMergeItem> list = getTagMergeItems(model);
    225197
    226198        assertEquals(10, list.size());
Note: See TracChangeset for help on using the changeset viewer.