source: josm/trunk/test/unit/org/openstreetmap/josm/gui/conflict/nodes/NodeListMergeModelTest.java@ 1622

Last change on this file since 1622 was 1622, checked in by Gubaer, 15 years ago

first version of extended conflict resolution dialog.

File size: 29.5 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.gui.conflict.nodes;
3
4import static org.junit.Assert.assertEquals;
5import static org.junit.Assert.assertTrue;
6import static org.junit.Assert.fail;
7
8import java.beans.PropertyChangeEvent;
9import java.beans.PropertyChangeListener;
10import java.lang.reflect.Field;
11import java.util.ArrayList;
12import java.util.List;
13
14import javax.swing.DefaultListSelectionModel;
15
16import org.junit.Test;
17import org.openstreetmap.josm.data.osm.Node;
18import org.openstreetmap.josm.data.osm.Way;
19import static org.fest.reflect.core.Reflection.field;
20
21public 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
30 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
38 protected void ensureSelected(DefaultListSelectionModel model, Object... idx) {
39 if (idx == null) return;
40 for (int i=0; i < idx.length; i++) {
41 if (idx[i] instanceof Integer) {
42 int j = (Integer)idx[i];
43 assertTrue("expected row " + j + " to be selected", model.isSelectedIndex(j));
44 break;
45 }
46 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 }
57 } catch(ClassCastException e) {
58 fail("illegal selection range:" + idx[i]);
59 }
60 }
61 }
62
63 @Test
64 public void test_copyMyNodesToTop_1() throws IllegalAccessException, NoSuchFieldException {
65 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
77 assertEquals(1, mergedNodes.size());
78 assertEquals(2, mergedNodes.get(0).id);
79
80 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
81 ensureSelected(mergedSelection, 0);
82
83 }
84
85
86 @Test
87 public void test_copyMyNodesToTop_2() throws IllegalAccessException, NoSuchFieldException {
88 NodeListMergeModel model = new NodeListMergeModel();
89
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");
99 mergedNodes.add(new Node(1));
100
101 model.copyMyNodesToTop(new int[]{0});
102
103 mergedNodes = inspectNodeList(model, "mergedNodes");
104 assertEquals(2, mergedNodes.size());
105 assertEquals(2, mergedNodes.get(0).id);
106 assertEquals(1, mergedNodes.get(1).id);
107
108 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
109 ensureSelected(mergedSelection, 0);
110
111 }
112
113
114
115
116
117 @Test
118 public void test_copyMyNodesToTop_3() throws IllegalAccessException, NoSuchFieldException {
119 NodeListMergeModel model = new NodeListMergeModel();
120
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");
130 mergedNodes.add(new Node(1));
131
132 model.copyMyNodesToTop(new int[]{1}); // copy node 3
133
134 mergedNodes = inspectNodeList(model, "mergedNodes");
135 assertEquals(2, mergedNodes.size());
136 assertEquals(3, mergedNodes.get(0).id); // my node 3 at position 0
137 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
143 @Test
144 public void test_copyMyNodesToTop_4() throws IllegalAccessException, NoSuchFieldException {
145 NodeListMergeModel model = new NodeListMergeModel();
146
147
148 Way myWay = new Way(1);
149 myWay.nodes.add(new Node(2));
150 myWay.nodes.add(new Node(3));
151 myWay.nodes.add(new Node(4));
152 Way theirWay = new Way(1);
153
154 model.populate(myWay, theirWay);
155
156 List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
157 mergedNodes.add(new Node(1));
158
159 model.copyMyNodesToTop(new int[]{1,2}); // copy node 3 and 4
160
161 mergedNodes = inspectNodeList(model, "mergedNodes");
162 assertEquals(3, mergedNodes.size());
163 assertEquals(3, mergedNodes.get(0).id); // my node 3 at position 0
164 assertEquals(4, mergedNodes.get(1).id); // my node 4 at position 1
165 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
172 @Test
173 public void test_copyMyNodesToEnd_1() throws IllegalAccessException, NoSuchFieldException {
174 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
186 assertEquals(1, mergedNodes.size());
187 assertEquals(2, mergedNodes.get(0).id);
188
189 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
190 ensureSelected(mergedSelection, 0);
191 }
192
193 @Test
194 public void test_copyMyNodesToEnd_2() throws IllegalAccessException, NoSuchFieldException {
195 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");
205 mergedNodes.add(new Node(1));
206
207 model.copyMyNodesToEnd(new int[]{0});
208
209 mergedNodes = inspectNodeList(model, "mergedNodes");
210 assertEquals(2, mergedNodes.size());
211 assertEquals(1, mergedNodes.get(0).id); // already merged node 1 at position 0
212 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
218 @Test
219 public void test_copyMyNodesToEnd_3() throws IllegalAccessException, NoSuchFieldException {
220 NodeListMergeModel model = new NodeListMergeModel();
221
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");
231 mergedNodes.add(new Node(1));
232
233 model.copyMyNodesToEnd(new int[]{1}); // copy node 3
234
235 mergedNodes = inspectNodeList(model, "mergedNodes");
236 assertEquals(2, mergedNodes.size());
237 assertEquals(1, mergedNodes.get(0).id); // already merged node 1 at position 0
238 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
245 @Test
246 public void test_copyMyNodesToEnd_4() throws IllegalAccessException, NoSuchFieldException {
247 NodeListMergeModel model = new NodeListMergeModel();
248
249
250 Way myWay = new Way(1);
251 myWay.nodes.add(new Node(2));
252 myWay.nodes.add(new Node(3));
253 myWay.nodes.add(new Node(4));
254 Way theirWay = new Way(1);
255
256 model.populate(myWay, theirWay);
257
258 List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
259 mergedNodes.add(new Node(1));
260
261 model.copyMyNodesToEnd(new int[]{1,2}); // copy node 3 and 4
262
263 mergedNodes = inspectNodeList(model, "mergedNodes");
264 assertEquals(3, mergedNodes.size());
265 assertEquals(1, mergedNodes.get(0).id); // already merged node 1 at position 0
266 assertEquals(3, mergedNodes.get(1).id); // my node 3 at position 1
267 assertEquals(4, mergedNodes.get(2).id); // my node 4 at position 2
268
269
270 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
271 ensureSelected(mergedSelection, 1,2); // last two rows selected
272 }
273
274 /* ----------------------------------------------------------------------------- */
275 /* copyMyNodesBeforeCurrent */
276 /* ----------------------------------------------------------------------------- */
277
278 @Test
279 public void test_copyMyNodesBeforeCurrent_1() throws IllegalAccessException, NoSuchFieldException {
280 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
295 assertEquals(4, mergedNodes.size());
296 assertEquals(10, mergedNodes.get(0).id); // already merged node
297 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
306 @Test
307 public void test_copyMyNodesBeforeCurrent_2() throws IllegalAccessException, NoSuchFieldException {
308 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
323 assertEquals(5, mergedNodes.size());
324 assertEquals(1, mergedNodes.get(0).id); // copied node 1 at position 0
325 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
334 @Test
335 public void test_copyMyNodesBeforeCurrent_3() throws IllegalAccessException, NoSuchFieldException {
336 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);
351 fail("expected IllegalArgumentException");
352 } catch(IllegalArgumentException e) {
353 // OK
354 }
355
356 try {
357 model.copyMyNodesBeforeCurrent(new int[]{0,1}, 3);
358 fail("expected IllegalArgumentException");
359 } catch(IllegalArgumentException e) {
360 // OK
361 }
362 }
363
364 /* ----------------------------------------------------------------------------- */
365 /* copyMyNodesAfterCurrent */
366 /* ----------------------------------------------------------------------------- */
367 @Test
368 public void test_copyMyNodesAfterCurrent_1() throws IllegalAccessException, NoSuchFieldException {
369 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
384 assertEquals(4, mergedNodes.size());
385 assertEquals(10, mergedNodes.get(0).id); // already merged node
386 assertEquals(11, mergedNodes.get(1).id); // already merged node
387 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
395 @Test
396 public void test_copyMyNodesAfterCurrent_2() throws IllegalAccessException, NoSuchFieldException {
397 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
413 assertEquals(5, mergedNodes.size());
414 assertEquals(10, mergedNodes.get(0).id); // already merged node
415 assertEquals(11, mergedNodes.get(1).id); // already merged node
416 assertEquals(12, mergedNodes.get(2).id); // already merged node
417 assertEquals(1, mergedNodes.get(3).id); // copied node 1 at position 3
418 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
425 @Test
426 public void test_copyMyNodesAfterCurrent_3() throws IllegalAccessException, NoSuchFieldException {
427 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
443 assertEquals(5, mergedNodes.size());
444 assertEquals(10, mergedNodes.get(0).id); // already merged node
445 assertEquals(1, mergedNodes.get(1).id); // copied node 1 at position 1
446 assertEquals(3, mergedNodes.get(2).id); // copied node 3 at position 2
447 assertEquals(11, mergedNodes.get(3).id); // already merged node
448 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
454 @Test
455 public void test_copyMyNodesAfterCurrent_4() throws IllegalAccessException, NoSuchFieldException {
456 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);
471 fail("expected IllegalArgumentException");
472 } catch(IllegalArgumentException e) {
473 // OK
474 }
475
476 try {
477 model.copyMyNodesAfterCurrent(new int[]{0,1}, 3);
478 fail("expected IllegalArgumentException");
479 } catch(IllegalArgumentException e) {
480 // OK
481 }
482 }
483
484 /* ----------------------------------------------------------------------------- */
485 /* moveUpMergedNodes */
486 /* ----------------------------------------------------------------------------- */
487 @Test
488 public void test_moveUpMergedNodes_1() throws IllegalAccessException, NoSuchFieldException {
489 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
504 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
513 @Test
514 public void test_moveUpMergedNodes_2() throws IllegalAccessException, NoSuchFieldException {
515 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");
524 mergedNodes.add(new Node(10));
525 mergedNodes.add(new Node(11));
526 mergedNodes.add(new Node(12));
527 mergedNodes.add(new Node(13));
528 mergedNodes.add(new Node(14));
529
530 model.moveUpMergedNodes(new int[]{1,4});
531
532 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);
536 assertEquals(14, mergedNodes.get(3).id);
537 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
543 @Test
544 public void test_moveUpMergedNodes_3() throws IllegalAccessException, NoSuchFieldException {
545 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");
554 mergedNodes.add(new Node(10));
555 mergedNodes.add(new Node(11));
556 mergedNodes.add(new Node(12));
557 mergedNodes.add(new Node(13));
558 mergedNodes.add(new Node(14));
559
560 model.moveUpMergedNodes(new int[]{1,2,3,4});
561
562 assertEquals(5, mergedNodes.size());
563 assertEquals(11, mergedNodes.get(0).id);
564 assertEquals(12, mergedNodes.get(1).id);
565 assertEquals(13, mergedNodes.get(2).id);
566 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
573 /* ----------------------------------------------------------------------------- */
574 /* moveDownMergedNodes */
575 /* ----------------------------------------------------------------------------- */
576 @Test
577 public void test_moveDownMergedNodes_1() throws IllegalAccessException, NoSuchFieldException {
578 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
593 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
602 @Test
603 public void test_moveDownMergedNodes_2() throws IllegalAccessException, NoSuchFieldException {
604 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");
613 mergedNodes.add(new Node(10));
614 mergedNodes.add(new Node(11));
615 mergedNodes.add(new Node(12));
616 mergedNodes.add(new Node(13));
617 mergedNodes.add(new Node(14));
618
619 model.moveDownMergedNodes(new int[]{1,3});
620
621 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);
625 assertEquals(14, mergedNodes.get(3).id);
626 assertEquals(13, mergedNodes.get(4).id);
627
628 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
629 ensureSelected(mergedSelection, 2,4);
630 }
631
632 @Test
633 public void test_moveDownMergedNodes_3() throws IllegalAccessException, NoSuchFieldException {
634 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");
643 mergedNodes.add(new Node(10));
644 mergedNodes.add(new Node(11));
645 mergedNodes.add(new Node(12));
646 mergedNodes.add(new Node(13));
647 mergedNodes.add(new Node(14));
648
649 model.moveDownMergedNodes(new int[]{1,2,3});
650
651 assertEquals(5, mergedNodes.size());
652 assertEquals(10, mergedNodes.get(0).id);
653 assertEquals(14, mergedNodes.get(1).id);
654 assertEquals(11, mergedNodes.get(2).id);
655 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
662 /* ----------------------------------------------------------------------------- */
663 /* PropertyChangeListener */
664 /* ----------------------------------------------------------------------------- */
665 @Test
666 public void addPropertyChangeListener() {
667 NodeListMergeModel model = new NodeListMergeModel();
668
669 PropertyChangeListener listener = new PropertyChangeListener() {
670 @Override
671 public void propertyChange(PropertyChangeEvent evt) {
672 }
673 };
674
675 model.addPropertyChangeListener(listener);
676
677 ArrayList<PropertyChangeListener> listeners = field("listeners")
678 .ofType(ArrayList.class)
679 .in(model)
680 .get();
681
682 assertEquals(1, listeners.size());
683 assertEquals(listener, listeners.get(0));
684 }
685
686 @Test
687 public void removePropertyChangeListener() {
688 NodeListMergeModel model = new NodeListMergeModel();
689
690 PropertyChangeListener listener = new PropertyChangeListener() {
691 @Override
692 public void propertyChange(PropertyChangeEvent evt) {
693 }
694 };
695
696 model.addPropertyChangeListener(listener);
697 model.removePropertyChangeListener(listener);
698
699 ArrayList<PropertyChangeListener> listeners = field("listeners")
700 .ofType(ArrayList.class)
701 .in(model)
702 .get();
703
704 assertEquals(0, listeners.size());
705 }
706
707 /* ----------------------------------------------------------------------------- */
708 /* property frozen */
709 /* ----------------------------------------------------------------------------- */
710 @Test
711 public void setFrozen() {
712 NodeListMergeModel model = new NodeListMergeModel();
713 model.setFrozen(true);
714 assertTrue(model.isFrozen());
715
716 model.setFrozen(false);
717 assertTrue(!model.isFrozen());
718 }
719
720 @Test
721 public void setFrozenWithPropertyChangeNotification() {
722 NodeListMergeModel model = new NodeListMergeModel();
723
724 class MyListener implements PropertyChangeListener {
725 public ArrayList<PropertyChangeEvent> events = new ArrayList<PropertyChangeEvent>();
726 @Override
727 public void propertyChange(PropertyChangeEvent evt) {
728 events.add(evt);
729 }
730 };
731 MyListener listener = new MyListener();
732 model.addPropertyChangeListener(listener);
733 boolean oldValue = model.isFrozen();
734 model.setFrozen(!oldValue);
735 assertEquals(!oldValue, model.isFrozen());
736
737 assertEquals(1, listener.events.size());
738 assertEquals(oldValue, listener.events.get(0).getOldValue());
739 assertEquals(!oldValue, listener.events.get(0).getNewValue());
740 }
741
742}
Note: See TracBrowser for help on using the repository browser.