Changeset 1631 in josm for trunk/test/unit


Ignore:
Timestamp:
2009-06-01T22:20:03+02:00 (11 years ago)
Author:
Gubaer
Message:

added support for merging member lists of relations in extended conflict resolution dialog

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

Legend:

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

    r1622 r1631  
    22package org.openstreetmap.josm.gui.conflict.nodes;
    33
     4import static org.fest.reflect.core.Reflection.field;
    45import static org.junit.Assert.assertEquals;
    56import static org.junit.Assert.assertTrue;
     
    89import java.beans.PropertyChangeEvent;
    910import java.beans.PropertyChangeListener;
    10 import java.lang.reflect.Field;
    1111import java.util.ArrayList;
    1212import java.util.List;
     
    1717import org.openstreetmap.josm.data.osm.Node;
    1818import org.openstreetmap.josm.data.osm.Way;
    19 import static org.fest.reflect.core.Reflection.field;
    2019
    2120public class NodeListMergeModelTest {
    22    
    23     protected List<Node> inspectNodeList(NodeListMergeModel model, String name) throws NoSuchFieldException, IllegalAccessException{
    24         Field f = NodeListMergeModel.class.getDeclaredField(name);
    25         f.setAccessible(true);
    26         Object o = f.get(model);
    27         return (List<Node>)o;
    28     }
    29    
     21
     22    protected List<Node> inspectNodeList(NodeListMergeModel model, String name) {
     23        return field(name).ofType(ArrayList.class)
     24        .in(model)
     25        .get();
     26    }
     27
    3028    protected DefaultListSelectionModel inspectListSelectionModel(NodeListMergeModel model, String name) throws NoSuchFieldException, IllegalAccessException {
    31         Field f = NodeListMergeModel.class.getDeclaredField(name);
    32         f.setAccessible(true);
    33         Object o = f.get(model);
    34         return (DefaultListSelectionModel)o;
    35        
    36     }
    37    
     29        return field(name).ofType(DefaultListSelectionModel.class)
     30        .in(model)
     31        .get();
     32    }
     33
    3834    protected void ensureSelected(DefaultListSelectionModel model, Object... idx) {
    3935        if (idx == null) return;
     
    4339                assertTrue("expected row " + j + " to be selected", model.isSelectedIndex(j));
    4440                break;
    45             } 
     41            }
    4642            try {
    47               int rows[] = (int[])idx[i];
    48               if (rows == null || rows.length != 2) {
    49                   fail("illegal selection range. Either null or not length 2: " + rows);
    50               }
    51               if (rows[0] > rows[1]) {
    52                   fail("illegal selection range. lower bound > upper bound ");
    53               }
    54               for (int j = rows[0]; j <= rows[1]; j++) {
    55                   assertTrue("expected row " + j + " to be selected", model.isSelectedIndex(j));
    56               }
     43                int rows[] = (int[])idx[i];
     44                if (rows == null || rows.length != 2) {
     45                    fail("illegal selection range. Either null or not length 2: " + rows);
     46                }
     47                if (rows[0] > rows[1]) {
     48                    fail("illegal selection range. lower bound > upper bound ");
     49                }
     50                for (int j = rows[0]; j <= rows[1]; j++) {
     51                    assertTrue("expected row " + j + " to be selected", model.isSelectedIndex(j));
     52                }
    5753            } catch(ClassCastException e) {
    5854                fail("illegal selection range:" + idx[i]);
    59             }           
     55            }
    6056        }
    6157    }
    62    
     58
    6359    @Test
    6460    public void test_copyMyNodesToTop_1() throws IllegalAccessException, NoSuchFieldException {
    6561        NodeListMergeModel model = new NodeListMergeModel();
    66        
    67         Way myWay = new Way(1);
    68         myWay.nodes.add(new Node(2));
    69         myWay.nodes.add(new Node(3));
    70         Way theirWay = new Way(1);
    71 
    72         model.populate(myWay, theirWay);
    73         model.copyMyNodesToTop(new int[]{0});
    74        
    75         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
    76        
     62
     63        Way myWay = new Way(1);
     64        myWay.nodes.add(new Node(2));
     65        myWay.nodes.add(new Node(3));
     66        Way theirWay = new Way(1);
     67
     68        model.populate(myWay, theirWay);
     69        model.copyMyToTop(new int[]{0});
     70
     71        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
     72
    7773        assertEquals(1, mergedNodes.size());
    7874        assertEquals(2, mergedNodes.get(0).id);
    79        
    80         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    81         ensureSelected(mergedSelection, 0);       
    82 
    83     }
    84    
    85    
     75
     76        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     77        ensureSelected(mergedSelection, 0);
     78
     79    }
     80
     81
    8682    @Test
    8783    public void test_copyMyNodesToTop_2() throws IllegalAccessException, NoSuchFieldException {
    8884        NodeListMergeModel model = new NodeListMergeModel();
    8985
    90        
    91         Way myWay = new Way(1);
    92         myWay.nodes.add(new Node(2));
    93         myWay.nodes.add(new Node(3));
    94         Way theirWay = new Way(1);
    95 
    96         model.populate(myWay, theirWay);
    97 
    98         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
     86
     87        Way myWay = new Way(1);
     88        myWay.nodes.add(new Node(2));
     89        myWay.nodes.add(new Node(3));
     90        Way theirWay = new Way(1);
     91
     92        model.populate(myWay, theirWay);
     93
     94        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
    9995        mergedNodes.add(new Node(1));
    10096
    101         model.copyMyNodesToTop(new int[]{0});
    102        
    103         mergedNodes = inspectNodeList(model, "mergedNodes");
     97        model.copyMyToTop(new int[]{0});
     98
     99        mergedNodes = inspectNodeList(model, "mergedEntries");
    104100        assertEquals(2, mergedNodes.size());
    105101        assertEquals(2, mergedNodes.get(0).id);
    106102        assertEquals(1, mergedNodes.get(1).id);
    107        
    108         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    109         ensureSelected(mergedSelection, 0);       
    110 
    111     }
    112    
    113    
    114 
    115    
    116    
     103
     104        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     105        ensureSelected(mergedSelection, 0);
     106
     107    }
     108
     109
     110
     111
     112
    117113    @Test
    118114    public void test_copyMyNodesToTop_3() throws IllegalAccessException, NoSuchFieldException {
    119115        NodeListMergeModel model = new NodeListMergeModel();
    120116
    121        
    122         Way myWay = new Way(1);
    123         myWay.nodes.add(new Node(2));
    124         myWay.nodes.add(new Node(3));
    125         Way theirWay = new Way(1);
    126 
    127         model.populate(myWay, theirWay);
    128 
    129         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
     117
     118        Way myWay = new Way(1);
     119        myWay.nodes.add(new Node(2));
     120        myWay.nodes.add(new Node(3));
     121        Way theirWay = new Way(1);
     122
     123        model.populate(myWay, theirWay);
     124
     125        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
    130126        mergedNodes.add(new Node(1));
    131127
    132         model.copyMyNodesToTop(new int[]{1}); // copy node 3
    133        
    134         mergedNodes = inspectNodeList(model, "mergedNodes");
     128        model.copyMyToTop(new int[]{1}); // copy node 3
     129
     130        mergedNodes = inspectNodeList(model, "mergedEntries");
    135131        assertEquals(2, mergedNodes.size());
    136132        assertEquals(3, mergedNodes.get(0).id); // my node 3 at position 0
    137133        assertEquals(1, mergedNodes.get(1).id); // already merged node 1 at position 1
    138        
    139         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    140         ensureSelected(mergedSelection, 0);       
    141     }
    142    
     134
     135        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     136        ensureSelected(mergedSelection, 0);
     137    }
     138
    143139    @Test
    144140    public void test_copyMyNodesToTop_4() throws IllegalAccessException, NoSuchFieldException {
    145141        NodeListMergeModel model = new NodeListMergeModel();
    146142
    147        
     143
    148144        Way myWay = new Way(1);
    149145        myWay.nodes.add(new Node(2));
     
    154150        model.populate(myWay, theirWay);
    155151
    156         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
     152        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
    157153        mergedNodes.add(new Node(1));
    158154
    159         model.copyMyNodesToTop(new int[]{1,2}); // copy node 3 and 4
    160        
    161         mergedNodes = inspectNodeList(model, "mergedNodes");
     155        model.copyMyToTop(new int[]{1,2}); // copy node 3 and 4
     156
     157        mergedNodes = inspectNodeList(model, "mergedEntries");
    162158        assertEquals(3, mergedNodes.size());
    163159        assertEquals(3, mergedNodes.get(0).id); // my node 3 at position 0
    164160        assertEquals(4, mergedNodes.get(1).id); // my node 4 at position 1
    165161        assertEquals(1, mergedNodes.get(2).id); // already merged node 1 at position 2
    166        
    167         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    168         ensureSelected(mergedSelection, 0,1); // first two rows selected       
    169     }
    170    
    171    
     162
     163        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     164        ensureSelected(mergedSelection, 0,1); // first two rows selected
     165    }
     166
     167
    172168    @Test
    173169    public void test_copyMyNodesToEnd_1() throws IllegalAccessException, NoSuchFieldException {
    174170        NodeListMergeModel model = new NodeListMergeModel();
    175        
    176         Way myWay = new Way(1);
    177         myWay.nodes.add(new Node(2));
    178         myWay.nodes.add(new Node(3));
    179         Way theirWay = new Way(1);
    180 
    181         model.populate(myWay, theirWay);
    182         model.copyMyNodesToEnd(new int[]{0});
    183        
    184         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
    185        
     171
     172        Way myWay = new Way(1);
     173        myWay.nodes.add(new Node(2));
     174        myWay.nodes.add(new Node(3));
     175        Way theirWay = new Way(1);
     176
     177        model.populate(myWay, theirWay);
     178        model.copyMyToEnd(new int[]{0});
     179
     180        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
     181
    186182        assertEquals(1, mergedNodes.size());
    187183        assertEquals(2, mergedNodes.get(0).id);
    188        
    189         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    190         ensureSelected(mergedSelection, 0);       
    191     }
    192    
     184
     185        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     186        ensureSelected(mergedSelection, 0);
     187    }
     188
    193189    @Test
    194190    public void test_copyMyNodesToEnd_2() throws IllegalAccessException, NoSuchFieldException {
    195191        NodeListMergeModel model = new NodeListMergeModel();
    196        
    197         Way myWay = new Way(1);
    198         myWay.nodes.add(new Node(2));
    199         myWay.nodes.add(new Node(3));
    200         Way theirWay = new Way(1);
    201 
    202         model.populate(myWay, theirWay);
    203 
    204         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
     192
     193        Way myWay = new Way(1);
     194        myWay.nodes.add(new Node(2));
     195        myWay.nodes.add(new Node(3));
     196        Way theirWay = new Way(1);
     197
     198        model.populate(myWay, theirWay);
     199
     200        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
    205201        mergedNodes.add(new Node(1));
    206202
    207         model.copyMyNodesToEnd(new int[]{0});
    208        
    209         mergedNodes = inspectNodeList(model, "mergedNodes");
     203        model.copyMyToEnd(new int[]{0});
     204
     205        mergedNodes = inspectNodeList(model, "mergedEntries");
    210206        assertEquals(2, mergedNodes.size());
    211207        assertEquals(1, mergedNodes.get(0).id); // already merged node 1 at position 0
    212208        assertEquals(2, mergedNodes.get(1).id); // copied node 2 at position 1
    213        
    214         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    215         ensureSelected(mergedSelection, 1);       
    216     }
    217    
     209
     210        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     211        ensureSelected(mergedSelection, 1);
     212    }
     213
    218214    @Test
    219215    public void test_copyMyNodesToEnd_3() throws IllegalAccessException, NoSuchFieldException {
    220216        NodeListMergeModel model = new NodeListMergeModel();
    221217
    222        
    223         Way myWay = new Way(1);
    224         myWay.nodes.add(new Node(2));
    225         myWay.nodes.add(new Node(3));
    226         Way theirWay = new Way(1);
    227 
    228         model.populate(myWay, theirWay);
    229 
    230         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
     218
     219        Way myWay = new Way(1);
     220        myWay.nodes.add(new Node(2));
     221        myWay.nodes.add(new Node(3));
     222        Way theirWay = new Way(1);
     223
     224        model.populate(myWay, theirWay);
     225
     226        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
    231227        mergedNodes.add(new Node(1));
    232228
    233         model.copyMyNodesToEnd(new int[]{1}); // copy node 3
    234        
    235         mergedNodes = inspectNodeList(model, "mergedNodes");
     229        model.copyMyToEnd(new int[]{1}); // copy node 3
     230
     231        mergedNodes = inspectNodeList(model, "mergedEntries");
    236232        assertEquals(2, mergedNodes.size());
    237233        assertEquals(1, mergedNodes.get(0).id); // already merged node 1 at position 0
    238234        assertEquals(3, mergedNodes.get(1).id); // my node 3 at position 1
    239        
    240        
    241         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    242         ensureSelected(mergedSelection, 1);       
    243     }
    244    
     235
     236
     237        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     238        ensureSelected(mergedSelection, 1);
     239    }
     240
    245241    @Test
    246242    public void test_copyMyNodesToEnd_4() throws IllegalAccessException, NoSuchFieldException {
    247243        NodeListMergeModel model = new NodeListMergeModel();
    248244
    249        
     245
    250246        Way myWay = new Way(1);
    251247        myWay.nodes.add(new Node(2));
     
    256252        model.populate(myWay, theirWay);
    257253
    258         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
     254        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
    259255        mergedNodes.add(new Node(1));
    260256
    261         model.copyMyNodesToEnd(new int[]{1,2}); // copy node 3 and 4
    262        
    263         mergedNodes = inspectNodeList(model, "mergedNodes");
     257        model.copyMyToEnd(new int[]{1,2}); // copy node 3 and 4
     258
     259        mergedNodes = inspectNodeList(model, "mergedEntries");
    264260        assertEquals(3, mergedNodes.size());
    265261        assertEquals(1, mergedNodes.get(0).id); // already merged node 1 at position 0
     
    267263        assertEquals(4, mergedNodes.get(2).id); // my node 4 at position 2
    268264
    269        
    270         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    271         ensureSelected(mergedSelection, 1,2); // last two rows selected       
    272     }
    273    
     265
     266        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     267        ensureSelected(mergedSelection, 1,2); // last two rows selected
     268    }
     269
    274270    /* ----------------------------------------------------------------------------- */
    275271    /* copyMyNodesBeforeCurrent                                                      */
    276272    /* ----------------------------------------------------------------------------- */
    277    
     273
    278274    @Test
    279275    public void test_copyMyNodesBeforeCurrent_1() throws IllegalAccessException, NoSuchFieldException {
    280276        NodeListMergeModel model = new NodeListMergeModel();
    281        
    282         Way myWay = new Way(1);
    283         myWay.nodes.add(new Node(1));
    284         myWay.nodes.add(new Node(2));
    285         Way theirWay = new Way(1);
    286 
    287         model.populate(myWay, theirWay);
    288         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
    289         mergedNodes.add(new Node(10));
    290         mergedNodes.add(new Node(11));
    291         mergedNodes.add(new Node(12));
    292        
    293         model.copyMyNodesBeforeCurrent(new int[]{0}, 1);
    294                
     277
     278        Way myWay = new Way(1);
     279        myWay.nodes.add(new Node(1));
     280        myWay.nodes.add(new Node(2));
     281        Way theirWay = new Way(1);
     282
     283        model.populate(myWay, theirWay);
     284        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
     285        mergedNodes.add(new Node(10));
     286        mergedNodes.add(new Node(11));
     287        mergedNodes.add(new Node(12));
     288
     289        model.copyMyBeforeCurrent(new int[]{0}, 1);
     290
    295291        assertEquals(4, mergedNodes.size());
    296         assertEquals(10, mergedNodes.get(0).id); // already merged node 
     292        assertEquals(10, mergedNodes.get(0).id); // already merged node
    297293        assertEquals(1, mergedNodes.get(1).id);  // copied node 1 at position 1
    298         assertEquals(11, mergedNodes.get(2).id); // already merged node 
    299         assertEquals(12, mergedNodes.get(3).id); // already merged node 
    300        
    301         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    302         ensureSelected(mergedSelection, 1); // position 1 selected       
    303     }
    304    
    305    
     294        assertEquals(11, mergedNodes.get(2).id); // already merged node
     295        assertEquals(12, mergedNodes.get(3).id); // already merged node
     296
     297        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     298        ensureSelected(mergedSelection, 1); // position 1 selected
     299    }
     300
     301
    306302    @Test
    307303    public void test_copyMyNodesBeforeCurrent_2() throws IllegalAccessException, NoSuchFieldException {
    308304        NodeListMergeModel model = new NodeListMergeModel();
    309        
    310         Way myWay = new Way(1);
    311         myWay.nodes.add(new Node(1));
    312         myWay.nodes.add(new Node(2));
    313         Way theirWay = new Way(1);
    314 
    315         model.populate(myWay, theirWay);
    316         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
    317         mergedNodes.add(new Node(10));
    318         mergedNodes.add(new Node(11));
    319         mergedNodes.add(new Node(12));
    320        
    321         model.copyMyNodesBeforeCurrent(new int[]{0,1}, 0);
    322                
     305
     306        Way myWay = new Way(1);
     307        myWay.nodes.add(new Node(1));
     308        myWay.nodes.add(new Node(2));
     309        Way theirWay = new Way(1);
     310
     311        model.populate(myWay, theirWay);
     312        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
     313        mergedNodes.add(new Node(10));
     314        mergedNodes.add(new Node(11));
     315        mergedNodes.add(new Node(12));
     316
     317        model.copyMyBeforeCurrent(new int[]{0,1}, 0);
     318
    323319        assertEquals(5, mergedNodes.size());
    324320        assertEquals(1, mergedNodes.get(0).id);  // copied node 1 at position 0
    325321        assertEquals(2, mergedNodes.get(1).id);  // copied node 2 at position 1
    326         assertEquals(10, mergedNodes.get(2).id); // already merged node 
    327         assertEquals(11, mergedNodes.get(3).id); // already merged node 
    328         assertEquals(12, mergedNodes.get(4).id); // already merged node 
    329        
    330         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    331         ensureSelected(mergedSelection, 0,1); // position 0 and 1 selected       
    332     }
    333    
     322        assertEquals(10, mergedNodes.get(2).id); // already merged node
     323        assertEquals(11, mergedNodes.get(3).id); // already merged node
     324        assertEquals(12, mergedNodes.get(4).id); // already merged node
     325
     326        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     327        ensureSelected(mergedSelection, 0,1); // position 0 and 1 selected
     328    }
     329
    334330    @Test
    335331    public void test_copyMyNodesBeforeCurrent_3() throws IllegalAccessException, NoSuchFieldException {
    336332        NodeListMergeModel model = new NodeListMergeModel();
    337        
    338         Way myWay = new Way(1);
    339         myWay.nodes.add(new Node(1));
    340         myWay.nodes.add(new Node(2));
    341         Way theirWay = new Way(1);
    342 
    343         model.populate(myWay, theirWay);
    344         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
    345         mergedNodes.add(new Node(10));
    346         mergedNodes.add(new Node(11));
    347         mergedNodes.add(new Node(12));
    348        
    349         try {               
    350             model.copyMyNodesBeforeCurrent(new int[]{0,1}, -1);
     333
     334        Way myWay = new Way(1);
     335        myWay.nodes.add(new Node(1));
     336        myWay.nodes.add(new Node(2));
     337        Way theirWay = new Way(1);
     338
     339        model.populate(myWay, theirWay);
     340        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
     341        mergedNodes.add(new Node(10));
     342        mergedNodes.add(new Node(11));
     343        mergedNodes.add(new Node(12));
     344
     345        try {
     346            model.copyMyBeforeCurrent(new int[]{0,1}, -1);
    351347            fail("expected IllegalArgumentException");
    352348        } catch(IllegalArgumentException e) {
    353349            // OK
    354350        }
    355                
    356         try {               
    357             model.copyMyNodesBeforeCurrent(new int[]{0,1}, 3);
     351
     352        try {
     353            model.copyMyBeforeCurrent(new int[]{0,1}, 3);
    358354            fail("expected IllegalArgumentException");
    359355        } catch(IllegalArgumentException e) {
    360356            // OK
    361         }     
    362     }
    363    
     357        }
     358    }
     359
    364360    /* ----------------------------------------------------------------------------- */
    365361    /* copyMyNodesAfterCurrent                                                       */
     
    368364    public void test_copyMyNodesAfterCurrent_1() throws IllegalAccessException, NoSuchFieldException {
    369365        NodeListMergeModel model = new NodeListMergeModel();
    370        
    371         Way myWay = new Way(1);
    372         myWay.nodes.add(new Node(1));
    373         myWay.nodes.add(new Node(2));
    374         Way theirWay = new Way(1);
    375 
    376         model.populate(myWay, theirWay);
    377         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
    378         mergedNodes.add(new Node(10));
    379         mergedNodes.add(new Node(11));
    380         mergedNodes.add(new Node(12));
    381        
    382         model.copyMyNodesAfterCurrent(new int[]{0}, 1);
    383                
     366
     367        Way myWay = new Way(1);
     368        myWay.nodes.add(new Node(1));
     369        myWay.nodes.add(new Node(2));
     370        Way theirWay = new Way(1);
     371
     372        model.populate(myWay, theirWay);
     373        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
     374        mergedNodes.add(new Node(10));
     375        mergedNodes.add(new Node(11));
     376        mergedNodes.add(new Node(12));
     377
     378        model.copyMyAfterCurrent(new int[]{0}, 1);
     379
    384380        assertEquals(4, mergedNodes.size());
    385         assertEquals(10, mergedNodes.get(0).id); // already merged node 
    386         assertEquals(11, mergedNodes.get(1).id); // already merged node 
     381        assertEquals(10, mergedNodes.get(0).id); // already merged node
     382        assertEquals(11, mergedNodes.get(1).id); // already merged node
    387383        assertEquals(1, mergedNodes.get(2).id);  // copied node 1 at position 2
    388         assertEquals(12, mergedNodes.get(3).id); // already merged node 
    389        
    390         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    391         ensureSelected(mergedSelection, 2); // position 1 selected       
    392     }
    393    
    394    
     384        assertEquals(12, mergedNodes.get(3).id); // already merged node
     385
     386        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     387        ensureSelected(mergedSelection, 2); // position 1 selected
     388    }
     389
     390
    395391    @Test
    396392    public void test_copyMyNodesAfterCurrent_2() throws IllegalAccessException, NoSuchFieldException {
    397393        NodeListMergeModel model = new NodeListMergeModel();
    398        
    399         Way myWay = new Way(1);
    400         myWay.nodes.add(new Node(1));
    401         myWay.nodes.add(new Node(2));
    402         myWay.nodes.add(new Node(3));
    403         Way theirWay = new Way(1);
    404 
    405         model.populate(myWay, theirWay);
    406         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
    407         mergedNodes.add(new Node(10));
    408         mergedNodes.add(new Node(11));
    409         mergedNodes.add(new Node(12));
    410        
    411         model.copyMyNodesAfterCurrent(new int[]{0,1}, 2);
    412                
     394
     395        Way myWay = new Way(1);
     396        myWay.nodes.add(new Node(1));
     397        myWay.nodes.add(new Node(2));
     398        myWay.nodes.add(new Node(3));
     399        Way theirWay = new Way(1);
     400
     401        model.populate(myWay, theirWay);
     402        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
     403        mergedNodes.add(new Node(10));
     404        mergedNodes.add(new Node(11));
     405        mergedNodes.add(new Node(12));
     406
     407        model.copyMyAfterCurrent(new int[]{0,1}, 2);
     408
    413409        assertEquals(5, mergedNodes.size());
    414         assertEquals(10, mergedNodes.get(0).id); // already merged node 
     410        assertEquals(10, mergedNodes.get(0).id); // already merged node
    415411        assertEquals(11, mergedNodes.get(1).id); // already merged node
    416412        assertEquals(12, mergedNodes.get(2).id); // already merged node
    417413        assertEquals(1, mergedNodes.get(3).id);  // copied node 1 at position 3
    418414        assertEquals(2, mergedNodes.get(4).id);  // copied node 2 at position 4
    419          
    420        
    421         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    422         ensureSelected(mergedSelection, 3,4); // position 3,4 selected       
    423     }
    424    
     415
     416
     417        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     418        ensureSelected(mergedSelection, 3,4); // position 3,4 selected
     419    }
     420
    425421    @Test
    426422    public void test_copyMyNodesAfterCurrent_3() throws IllegalAccessException, NoSuchFieldException {
    427423        NodeListMergeModel model = new NodeListMergeModel();
    428        
    429         Way myWay = new Way(1);
    430         myWay.nodes.add(new Node(1));
    431         myWay.nodes.add(new Node(2));
    432         myWay.nodes.add(new Node(3));
    433         Way theirWay = new Way(1);
    434 
    435         model.populate(myWay, theirWay);
    436         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
    437         mergedNodes.add(new Node(10));
    438         mergedNodes.add(new Node(11));
    439         mergedNodes.add(new Node(12));
    440        
    441         model.copyMyNodesAfterCurrent(new int[]{0,2}, 0);
    442                
     424
     425        Way myWay = new Way(1);
     426        myWay.nodes.add(new Node(1));
     427        myWay.nodes.add(new Node(2));
     428        myWay.nodes.add(new Node(3));
     429        Way theirWay = new Way(1);
     430
     431        model.populate(myWay, theirWay);
     432        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
     433        mergedNodes.add(new Node(10));
     434        mergedNodes.add(new Node(11));
     435        mergedNodes.add(new Node(12));
     436
     437        model.copyMyAfterCurrent(new int[]{0,2}, 0);
     438
    443439        assertEquals(5, mergedNodes.size());
    444         assertEquals(10, mergedNodes.get(0).id); // already merged node 
     440        assertEquals(10, mergedNodes.get(0).id); // already merged node
    445441        assertEquals(1, mergedNodes.get(1).id);  // copied node 1 at position 1
    446442        assertEquals(3, mergedNodes.get(2).id);  // copied node 3 at position 2
    447443        assertEquals(11, mergedNodes.get(3).id); // already merged node
    448444        assertEquals(12, mergedNodes.get(4).id); // already merged node
    449        
    450         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    451         ensureSelected(mergedSelection, 1,2); // position 1,2 selected       
    452     }
    453    
     445
     446        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     447        ensureSelected(mergedSelection, 1,2); // position 1,2 selected
     448    }
     449
    454450    @Test
    455451    public void test_copyMyNodesAfterCurrent_4() throws IllegalAccessException, NoSuchFieldException {
    456452        NodeListMergeModel model = new NodeListMergeModel();
    457        
    458         Way myWay = new Way(1);
    459         myWay.nodes.add(new Node(1));
    460         myWay.nodes.add(new Node(2));
    461         Way theirWay = new Way(1);
    462 
    463         model.populate(myWay, theirWay);
    464         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
    465         mergedNodes.add(new Node(10));
    466         mergedNodes.add(new Node(11));
    467         mergedNodes.add(new Node(12));
    468        
    469         try {               
    470             model.copyMyNodesAfterCurrent(new int[]{0,1}, -1);
     453
     454        Way myWay = new Way(1);
     455        myWay.nodes.add(new Node(1));
     456        myWay.nodes.add(new Node(2));
     457        Way theirWay = new Way(1);
     458
     459        model.populate(myWay, theirWay);
     460        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
     461        mergedNodes.add(new Node(10));
     462        mergedNodes.add(new Node(11));
     463        mergedNodes.add(new Node(12));
     464
     465        try {
     466            model.copyMyAfterCurrent(new int[]{0,1}, -1);
    471467            fail("expected IllegalArgumentException");
    472468        } catch(IllegalArgumentException e) {
    473469            // OK
    474470        }
    475                
    476         try {               
    477             model.copyMyNodesAfterCurrent(new int[]{0,1}, 3);
     471
     472        try {
     473            model.copyMyAfterCurrent(new int[]{0,1}, 3);
    478474            fail("expected IllegalArgumentException");
    479475        } catch(IllegalArgumentException e) {
    480476            // OK
    481         }     
    482     }
    483    
     477        }
     478    }
     479
    484480    /* ----------------------------------------------------------------------------- */
    485481    /* moveUpMergedNodes                                                       */
     
    488484    public void test_moveUpMergedNodes_1() throws IllegalAccessException, NoSuchFieldException {
    489485        NodeListMergeModel model = new NodeListMergeModel();
    490        
    491         Way myWay = new Way(1);
    492         myWay.nodes.add(new Node(1));
    493         myWay.nodes.add(new Node(2));
    494         Way theirWay = new Way(1);
    495 
    496         model.populate(myWay, theirWay);
    497         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
    498         mergedNodes.add(new Node(10));
    499         mergedNodes.add(new Node(11));
    500         mergedNodes.add(new Node(12));
    501        
    502         model.moveUpMergedNodes(new int[]{1});
    503                
     486
     487        Way myWay = new Way(1);
     488        myWay.nodes.add(new Node(1));
     489        myWay.nodes.add(new Node(2));
     490        Way theirWay = new Way(1);
     491
     492        model.populate(myWay, theirWay);
     493        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
     494        mergedNodes.add(new Node(10));
     495        mergedNodes.add(new Node(11));
     496        mergedNodes.add(new Node(12));
     497
     498        model.moveUpMerged(new int[]{1});
     499
    504500        assertEquals(3, mergedNodes.size());
    505         assertEquals(11, mergedNodes.get(0).id); 
    506         assertEquals(10, mergedNodes.get(1).id); 
    507         assertEquals(12, mergedNodes.get(2).id);   
    508        
    509         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    510         ensureSelected(mergedSelection, 0); // position 1 selecte0       
    511     }
    512    
     501        assertEquals(11, mergedNodes.get(0).id);
     502        assertEquals(10, mergedNodes.get(1).id);
     503        assertEquals(12, mergedNodes.get(2).id);
     504
     505        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     506        ensureSelected(mergedSelection, 0); // position 1 selecte0
     507    }
     508
    513509    @Test
    514510    public void test_moveUpMergedNodes_2() throws IllegalAccessException, NoSuchFieldException {
    515511        NodeListMergeModel model = new NodeListMergeModel();
    516        
    517         Way myWay = new Way(1);
    518         myWay.nodes.add(new Node(1));
    519         myWay.nodes.add(new Node(2));
    520         Way theirWay = new Way(1);
    521 
    522         model.populate(myWay, theirWay);
    523         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
     512
     513        Way myWay = new Way(1);
     514        myWay.nodes.add(new Node(1));
     515        myWay.nodes.add(new Node(2));
     516        Way theirWay = new Way(1);
     517
     518        model.populate(myWay, theirWay);
     519        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
    524520        mergedNodes.add(new Node(10));
    525521        mergedNodes.add(new Node(11));
     
    527523        mergedNodes.add(new Node(13));
    528524        mergedNodes.add(new Node(14));
    529        
    530         model.moveUpMergedNodes(new int[]{1,4});
    531                
     525
     526        model.moveUpMerged(new int[]{1,4});
     527
    532528        assertEquals(5, mergedNodes.size());
    533         assertEquals(11, mergedNodes.get(0).id); 
    534         assertEquals(10, mergedNodes.get(1).id); 
    535         assertEquals(12, mergedNodes.get(2).id);   
     529        assertEquals(11, mergedNodes.get(0).id);
     530        assertEquals(10, mergedNodes.get(1).id);
     531        assertEquals(12, mergedNodes.get(2).id);
    536532        assertEquals(14, mergedNodes.get(3).id);
    537533        assertEquals(13, mergedNodes.get(4).id);
    538        
    539         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    540         ensureSelected(mergedSelection, 0,3); // position 0 and 3 selecte0       
    541     }
    542    
     534
     535        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     536        ensureSelected(mergedSelection, 0,3); // position 0 and 3 selecte0
     537    }
     538
    543539    @Test
    544540    public void test_moveUpMergedNodes_3() throws IllegalAccessException, NoSuchFieldException {
    545541        NodeListMergeModel model = new NodeListMergeModel();
    546        
    547         Way myWay = new Way(1);
    548         myWay.nodes.add(new Node(1));
    549         myWay.nodes.add(new Node(2));
    550         Way theirWay = new Way(1);
    551 
    552         model.populate(myWay, theirWay);
    553         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
     542
     543        Way myWay = new Way(1);
     544        myWay.nodes.add(new Node(1));
     545        myWay.nodes.add(new Node(2));
     546        Way theirWay = new Way(1);
     547
     548        model.populate(myWay, theirWay);
     549        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
    554550        mergedNodes.add(new Node(10));
    555551        mergedNodes.add(new Node(11));
     
    557553        mergedNodes.add(new Node(13));
    558554        mergedNodes.add(new Node(14));
    559        
    560         model.moveUpMergedNodes(new int[]{1,2,3,4});
    561                
     555
     556        model.moveUpMerged(new int[]{1,2,3,4});
     557
    562558        assertEquals(5, mergedNodes.size());
    563         assertEquals(11, mergedNodes.get(0).id); 
    564         assertEquals(12, mergedNodes.get(1).id);   
     559        assertEquals(11, mergedNodes.get(0).id);
     560        assertEquals(12, mergedNodes.get(1).id);
    565561        assertEquals(13, mergedNodes.get(2).id);
    566562        assertEquals(14, mergedNodes.get(3).id);
    567         assertEquals(10, mergedNodes.get(4).id); 
    568        
    569         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    570         ensureSelected(mergedSelection, 0,1,2,3);         
    571     }
    572    
     563        assertEquals(10, mergedNodes.get(4).id);
     564
     565        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     566        ensureSelected(mergedSelection, 0,1,2,3);
     567    }
     568
    573569    /* ----------------------------------------------------------------------------- */
    574570    /* moveDownMergedNodes                                                       */
     
    577573    public void test_moveDownMergedNodes_1() throws IllegalAccessException, NoSuchFieldException {
    578574        NodeListMergeModel model = new NodeListMergeModel();
    579        
    580         Way myWay = new Way(1);
    581         myWay.nodes.add(new Node(1));
    582         myWay.nodes.add(new Node(2));
    583         Way theirWay = new Way(1);
    584 
    585         model.populate(myWay, theirWay);
    586         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
    587         mergedNodes.add(new Node(10));
    588         mergedNodes.add(new Node(11));
    589         mergedNodes.add(new Node(12));
    590        
    591         model.moveDownMergedNodes(new int[]{1});
    592                
     575
     576        Way myWay = new Way(1);
     577        myWay.nodes.add(new Node(1));
     578        myWay.nodes.add(new Node(2));
     579        Way theirWay = new Way(1);
     580
     581        model.populate(myWay, theirWay);
     582        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
     583        mergedNodes.add(new Node(10));
     584        mergedNodes.add(new Node(11));
     585        mergedNodes.add(new Node(12));
     586
     587        model.moveDownMerged(new int[]{1});
     588
    593589        assertEquals(3, mergedNodes.size());
    594         assertEquals(10, mergedNodes.get(0).id); 
    595         assertEquals(12, mergedNodes.get(1).id); 
    596         assertEquals(11, mergedNodes.get(2).id);   
    597        
    598         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    599         ensureSelected(mergedSelection, 2);       
    600     }
    601    
     590        assertEquals(10, mergedNodes.get(0).id);
     591        assertEquals(12, mergedNodes.get(1).id);
     592        assertEquals(11, mergedNodes.get(2).id);
     593
     594        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     595        ensureSelected(mergedSelection, 2);
     596    }
     597
    602598    @Test
    603599    public void test_moveDownMergedNodes_2() throws IllegalAccessException, NoSuchFieldException {
    604600        NodeListMergeModel model = new NodeListMergeModel();
    605        
    606         Way myWay = new Way(1);
    607         myWay.nodes.add(new Node(1));
    608         myWay.nodes.add(new Node(2));
    609         Way theirWay = new Way(1);
    610 
    611         model.populate(myWay, theirWay);
    612         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
     601
     602        Way myWay = new Way(1);
     603        myWay.nodes.add(new Node(1));
     604        myWay.nodes.add(new Node(2));
     605        Way theirWay = new Way(1);
     606
     607        model.populate(myWay, theirWay);
     608        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
    613609        mergedNodes.add(new Node(10));
    614610        mergedNodes.add(new Node(11));
     
    616612        mergedNodes.add(new Node(13));
    617613        mergedNodes.add(new Node(14));
    618        
    619         model.moveDownMergedNodes(new int[]{1,3});
    620                
     614
     615        model.moveDownMerged(new int[]{1,3});
     616
    621617        assertEquals(5, mergedNodes.size());
    622         assertEquals(10, mergedNodes.get(0).id); 
    623         assertEquals(12, mergedNodes.get(1).id); 
    624         assertEquals(11, mergedNodes.get(2).id);   
     618        assertEquals(10, mergedNodes.get(0).id);
     619        assertEquals(12, mergedNodes.get(1).id);
     620        assertEquals(11, mergedNodes.get(2).id);
    625621        assertEquals(14, mergedNodes.get(3).id);
    626622        assertEquals(13, mergedNodes.get(4).id);
    627        
    628         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    629         ensureSelected(mergedSelection, 2,4);         
    630     }
    631    
     623
     624        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     625        ensureSelected(mergedSelection, 2,4);
     626    }
     627
    632628    @Test
    633629    public void test_moveDownMergedNodes_3() throws IllegalAccessException, NoSuchFieldException {
    634630        NodeListMergeModel model = new NodeListMergeModel();
    635        
    636         Way myWay = new Way(1);
    637         myWay.nodes.add(new Node(1));
    638         myWay.nodes.add(new Node(2));
    639         Way theirWay = new Way(1);
    640 
    641         model.populate(myWay, theirWay);
    642         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
     631
     632        Way myWay = new Way(1);
     633        myWay.nodes.add(new Node(1));
     634        myWay.nodes.add(new Node(2));
     635        Way theirWay = new Way(1);
     636
     637        model.populate(myWay, theirWay);
     638        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
    643639        mergedNodes.add(new Node(10));
    644640        mergedNodes.add(new Node(11));
     
    646642        mergedNodes.add(new Node(13));
    647643        mergedNodes.add(new Node(14));
    648        
    649         model.moveDownMergedNodes(new int[]{1,2,3});
    650                
     644
     645        model.moveDownMerged(new int[]{1,2,3});
     646
    651647        assertEquals(5, mergedNodes.size());
    652         assertEquals(10, mergedNodes.get(0).id); 
    653         assertEquals(14, mergedNodes.get(1).id);   
     648        assertEquals(10, mergedNodes.get(0).id);
     649        assertEquals(14, mergedNodes.get(1).id);
    654650        assertEquals(11, mergedNodes.get(2).id);
    655651        assertEquals(12, mergedNodes.get(3).id);
    656         assertEquals(13, mergedNodes.get(4).id); 
    657        
    658         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    659         ensureSelected(mergedSelection, 2,3,4);         
    660     }
    661    
     652        assertEquals(13, mergedNodes.get(4).id);
     653
     654        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     655        ensureSelected(mergedSelection, 2,3,4);
     656    }
     657
    662658    /* ----------------------------------------------------------------------------- */
    663659    /* PropertyChangeListener                                                        */
     
    666662    public void addPropertyChangeListener() {
    667663        NodeListMergeModel model = new NodeListMergeModel();
    668        
     664
    669665        PropertyChangeListener listener = new PropertyChangeListener() {
    670             @Override
     666
    671667            public void propertyChange(PropertyChangeEvent evt) {
    672668            }
    673669        };
    674        
     670
    675671        model.addPropertyChangeListener(listener);
    676        
     672
    677673        ArrayList<PropertyChangeListener> listeners = field("listeners")
    678           .ofType(ArrayList.class)
    679           .in(model)
    680           .get();
    681        
     674        .ofType(ArrayList.class)
     675        .in(model)
     676        .get();
     677
    682678        assertEquals(1, listeners.size());
    683679        assertEquals(listener, listeners.get(0));
    684680    }
    685    
     681
    686682    @Test
    687683    public void removePropertyChangeListener() {
    688684        NodeListMergeModel model = new NodeListMergeModel();
    689        
     685
    690686        PropertyChangeListener listener = new PropertyChangeListener() {
    691             @Override
     687
    692688            public void propertyChange(PropertyChangeEvent evt) {
    693689            }
    694690        };
    695        
     691
    696692        model.addPropertyChangeListener(listener);
    697693        model.removePropertyChangeListener(listener);
    698        
     694
    699695        ArrayList<PropertyChangeListener> listeners = field("listeners")
    700           .ofType(ArrayList.class)
    701           .in(model)
    702           .get();
    703        
     696        .ofType(ArrayList.class)
     697        .in(model)
     698        .get();
     699
    704700        assertEquals(0, listeners.size());
    705701    }
    706    
     702
    707703    /* ----------------------------------------------------------------------------- */
    708704    /* property frozen                                                               */
     
    721717    public void setFrozenWithPropertyChangeNotification() {
    722718        NodeListMergeModel model = new NodeListMergeModel();
    723        
     719
    724720        class MyListener implements PropertyChangeListener {
    725721            public ArrayList<PropertyChangeEvent> events = new ArrayList<PropertyChangeEvent>();
    726             @Override
     722
    727723            public void propertyChange(PropertyChangeEvent evt) {
    728724                events.add(evt);
     
    734730        model.setFrozen(!oldValue);
    735731        assertEquals(!oldValue, model.isFrozen());
    736        
     732
    737733        assertEquals(1, listener.events.size());
    738734        assertEquals(oldValue, listener.events.get(0).getOldValue());
  • trunk/test/unit/org/openstreetmap/josm/gui/conflict/tags/TagMergeModelTest.java

    r1622 r1631  
    1919        TagMergeModel model = new TagMergeModel();
    2020    }
    21    
     21
    2222    @Test
    2323    public void addPropertyChangeListener() {
    2424        TagMergeModel model = new TagMergeModel();
    2525        PropertyChangeListener listener = new PropertyChangeListener() {
    26             @Override
     26
    2727            public void propertyChange(PropertyChangeEvent evt) {
    2828            }
    2929        };
    3030        model.addPropertyChangeListener(listener);
    31        
     31
    3232        ArrayList list = field("listeners").ofType(ArrayList.class)
    33            .in(model)
    34            .get();
    35        
    36         assertEquals(1, list.size());
    37         assertEquals(listener, list.get(0));       
    38     }
    39    
     33        .in(model)
     34        .get();
     35
     36        assertEquals(1, list.size());
     37        assertEquals(listener, list.get(0));
     38    }
     39
    4040    @Test
    4141    public void removePropertyChangeListener() {
    4242        TagMergeModel model = new TagMergeModel();
    4343        PropertyChangeListener listener = new PropertyChangeListener() {
    44             @Override
     44
    4545            public void propertyChange(PropertyChangeEvent evt) {
    4646            }
     
    4848        model.addPropertyChangeListener(listener);
    4949        model.removePropertyChangeListener(listener);
    50        
     50
    5151        ArrayList list = field("listeners")
    52             .ofType(ArrayList.class)
    53             .in(model)
    54             .get();
    55      
    56          assertEquals(0, list.size());       
    57     }
    58    
     52        .ofType(ArrayList.class)
     53        .in(model)
     54        .get();
     55
     56        assertEquals(0, list.size());
     57    }
     58
    5959    @Test
    6060    public void populateNoConflichts() {
     
    6363        TagMergeModel model = new TagMergeModel();
    6464        model.populate(my, their);
    65        
    66         ArrayList<TagMergeItem> list = field("tagMergeItems")
    67             .ofType(ArrayList.class)
    68             .in(model)
    69             .get();
    70        
     65
     66        ArrayList<TagMergeItem> list = field("tagMergeItems")
     67        .ofType(ArrayList.class)
     68        .in(model)
     69        .get();
     70
    7171        assertEquals(0, list.size());
    7272    }
    73    
     73
    7474    @Test
    7575    public void populateNoConflicts1() {
     
    8080        TagMergeModel model = new TagMergeModel();
    8181        model.populate(my, their);
    82        
    83         ArrayList<TagMergeItem> list = field("tagMergeItems")
    84             .ofType(ArrayList.class)
    85             .in(model)
    86             .get();
    87        
     82
     83        ArrayList<TagMergeItem> list = field("tagMergeItems")
     84        .ofType(ArrayList.class)
     85        .in(model)
     86        .get();
     87
    8888        assertEquals(0, list.size());
    8989    }
    90    
     90
    9191    @Test
    9292    public void populateMissingKeyMine() {
     
    9696        TagMergeModel model = new TagMergeModel();
    9797        model.populate(my, their);
    98        
    99         ArrayList<TagMergeItem> list = field("tagMergeItems")
    100             .ofType(ArrayList.class)
    101             .in(model)
    102             .get();
    103        
     98
     99        ArrayList<TagMergeItem> list = field("tagMergeItems")
     100        .ofType(ArrayList.class)
     101        .in(model)
     102        .get();
     103
    104104        assertEquals(1, list.size());
    105105        TagMergeItem item = list.get(0);
     
    109109        assertEquals("value", item.getTheirTagValue());
    110110    }
    111    
     111
    112112    @Test
    113113    public void populateMissingKeyTheir() {
    114114        Node my = new Node(1);
    115115        my.put("key", "value");
    116         Node their = new Node(1);       
    117         TagMergeModel model = new TagMergeModel();
    118         model.populate(my, their);
    119        
    120         ArrayList<TagMergeItem> list = field("tagMergeItems")
    121             .ofType(ArrayList.class)
    122             .in(model)
    123             .get();
    124        
     116        Node their = new Node(1);
     117        TagMergeModel model = new TagMergeModel();
     118        model.populate(my, their);
     119
     120        ArrayList<TagMergeItem> list = field("tagMergeItems")
     121        .ofType(ArrayList.class)
     122        .in(model)
     123        .get();
     124
    125125        assertEquals(1, list.size());
    126126        TagMergeItem item = list.get(0);
     
    130130        assertEquals("value", item.getMyTagValue());
    131131    }
    132    
     132
    133133    @Test
    134134    public void populateConflictingValues() {
     
    139139        TagMergeModel model = new TagMergeModel();
    140140        model.populate(my, their);
    141        
    142         ArrayList<TagMergeItem> list = field("tagMergeItems")
    143             .ofType(ArrayList.class)
    144             .in(model)
    145             .get();
    146        
     141
     142        ArrayList<TagMergeItem> list = field("tagMergeItems")
     143        .ofType(ArrayList.class)
     144        .in(model)
     145        .get();
     146
    147147        assertEquals(1, list.size());
    148148        TagMergeItem item = list.get(0);
     
    152152        assertEquals("theirvalue", item.getTheirTagValue());
    153153    }
    154    
     154
    155155    @Test
    156156    public void addItem() {
     
    158158        TagMergeModel model = new TagMergeModel();
    159159        model.addItem(item);
    160        
    161         ArrayList<TagMergeItem> list = field("tagMergeItems")
    162             .ofType(ArrayList.class)
    163             .in(model)
    164             .get();
    165        
     160
     161        ArrayList<TagMergeItem> list = field("tagMergeItems")
     162        .ofType(ArrayList.class)
     163        .in(model)
     164        .get();
     165
    166166        assertEquals(1, list.size());
    167167        item = list.get(0);
     
    171171        assertEquals("theirvalue", item.getTheirTagValue());
    172172    }
    173    
     173
    174174    @Test
    175175    public void decide() {
     
    177177        TagMergeModel model = new TagMergeModel();
    178178        model.addItem(item);
    179              
    180         ArrayList<TagMergeItem> list = field("tagMergeItems")
    181             .ofType(ArrayList.class)
    182             .in(model)
    183             .get();
    184        
    185         model.decide(0, MergeDecisionType.KEEP_MINE); 
     179
     180        ArrayList<TagMergeItem> list = field("tagMergeItems")
     181        .ofType(ArrayList.class)
     182        .in(model)
     183        .get();
     184
     185        model.decide(0, MergeDecisionType.KEEP_MINE);
    186186        assertEquals(1, list.size());
    187187        item = list.get(0);
    188188        assertEquals(MergeDecisionType.KEEP_MINE, item.getMergeDecision());
    189        
    190         model.decide(0, MergeDecisionType.KEEP_THEIR); 
     189
     190        model.decide(0, MergeDecisionType.KEEP_THEIR);
    191191        assertEquals(1, list.size());
    192192        item = list.get(0);
    193193        assertEquals(MergeDecisionType.KEEP_THEIR, item.getMergeDecision());
    194        
    195         model.decide(0, MergeDecisionType.UNDECIDED); 
    196         assertEquals(1, list.size());
    197         item = list.get(0);
    198         assertEquals(MergeDecisionType.UNDECIDED, item.getMergeDecision());
    199     }
    200    
     194
     195        model.decide(0, MergeDecisionType.UNDECIDED);
     196        assertEquals(1, list.size());
     197        item = list.get(0);
     198        assertEquals(MergeDecisionType.UNDECIDED, item.getMergeDecision());
     199    }
     200
    201201    @Test
    202202    public void decideMultiple() {
    203        
     203
    204204        TagMergeItem item = new TagMergeItem("key", "myvalue", "theirvalue");
    205205        TagMergeModel model = new TagMergeModel();
     
    207207            model.addItem(new TagMergeItem("key-" + i, "myvalue-" + i, "theirvalue-" +i));
    208208        }
    209              
    210         ArrayList<TagMergeItem> list = field("tagMergeItems")
    211             .ofType(ArrayList.class)
    212             .in(model)
    213             .get();
    214        
     209
     210        ArrayList<TagMergeItem> list = field("tagMergeItems")
     211        .ofType(ArrayList.class)
     212        .in(model)
     213        .get();
     214
    215215        assertEquals(10, list.size());
    216        
    217         model.decide(new int[] {0, 3, 5}, MergeDecisionType.KEEP_MINE); 
     216
     217        model.decide(new int[] {0, 3, 5}, MergeDecisionType.KEEP_MINE);
    218218        for (int i = 0; i< 10; i++) {
    219219            item = list.get(i);
Note: See TracChangeset for help on using the changeset viewer.