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

Last change on this file since 2626 was 2626, checked in by jttt, 14 years ago

Fixed some of the warnings found by FindBugs
File size: 27.1 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.gui.conflict.nodes;
3
4import static org.fest.reflect.core.Reflection.field;
5import static org.fest.reflect.core.Reflection.method;
6import static org.junit.Assert.assertEquals;
7import static org.junit.Assert.assertTrue;
8import static org.junit.Assert.fail;
9
10import java.beans.PropertyChangeEvent;
11import java.beans.PropertyChangeListener;
12import java.util.ArrayList;
13import java.util.Arrays;
14import java.util.List;
15
16import javax.swing.DefaultListSelectionModel;
17
18import org.junit.Test;
19import org.openstreetmap.josm.data.osm.Node;
20import org.openstreetmap.josm.data.osm.Way;
21import org.openstreetmap.josm.gui.conflict.pair.nodes.NodeListMergeModel;
22
23public class NodeListMergeModelTest {
24
25 protected List<Node> inspectNodeList(NodeListMergeModel model, String name) {
26 return method("get" + name + "Entries")
27 .withReturnType(List.class)
28 .in(model)
29 .invoke();
30 }
31
32 protected DefaultListSelectionModel inspectListSelectionModel(NodeListMergeModel model, String name) {
33 return field(name).ofType(DefaultListSelectionModel.class)
34 .in(model)
35 .get();
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: " + Arrays.toString(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() {
65 NodeListMergeModel model = new NodeListMergeModel();
66
67 Way myWay = new Way(1, 1);
68 myWay.addNode(new Node(2));
69 myWay.addNode(new Node(3));
70 Way theirWay = new Way(1);
71
72 model.populate(myWay, theirWay);
73 model.copyMyToTop(new int[]{0});
74
75 List<Node> mergedNodes = inspectNodeList(model, "Merged");
76
77 assertEquals(1, mergedNodes.size());
78 assertEquals(2, mergedNodes.get(0).getId());
79
80 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
81 ensureSelected(mergedSelection, 0);
82
83 }
84
85
86 @Test
87 public void test_copyMyNodesToTop_2() {
88 NodeListMergeModel model = new NodeListMergeModel();
89
90
91 Way myWay = new Way(1, 1);
92 myWay.addNode(new Node(2));
93 myWay.addNode(new Node(3));
94 Way theirWay = new Way(1);
95
96 model.populate(myWay, theirWay);
97
98 List<Node> mergedNodes = inspectNodeList(model, "Merged");
99 mergedNodes.add(new Node(1));
100
101 model.copyMyToTop(new int[]{0});
102
103 mergedNodes = inspectNodeList(model, "Merged");
104 assertEquals(2, mergedNodes.size());
105 assertEquals(2, mergedNodes.get(0).getId());
106 assertEquals(1, mergedNodes.get(1).getId());
107
108 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
109 ensureSelected(mergedSelection, 0);
110
111 }
112
113
114
115
116
117 @Test
118 public void test_copyMyNodesToTop_3() {
119 NodeListMergeModel model = new NodeListMergeModel();
120
121
122 Way myWay = new Way(1, 1);
123 myWay.addNode(new Node(2));
124 myWay.addNode(new Node(3));
125 Way theirWay = new Way(1);
126
127
128 model.populate(myWay, theirWay);
129
130 List<Node> mergedNodes = inspectNodeList(model, "Merged");
131 mergedNodes.add(new Node(1));
132
133 model.copyMyToTop(new int[]{1}); // copy node 3
134
135 mergedNodes = inspectNodeList(model, "Merged");
136 assertEquals(2, mergedNodes.size());
137 assertEquals(3, mergedNodes.get(0).getId()); // my node 3 at position 0
138 assertEquals(1, mergedNodes.get(1).getId()); // already merged node 1 at position 1
139
140 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
141 ensureSelected(mergedSelection, 0);
142 }
143
144 @Test
145 public void test_copyMyNodesToTop_4() {
146 NodeListMergeModel model = new NodeListMergeModel();
147
148
149 Way myWay = new Way(1, 1);
150 myWay.addNode(new Node(2));
151 myWay.addNode(new Node(3));
152 myWay.addNode(new Node(4));
153 Way theirWay = new Way(1);
154
155 model.populate(myWay, theirWay);
156
157 List<Node> mergedNodes = inspectNodeList(model, "Merged");
158 mergedNodes.add(new Node(1));
159
160 model.copyMyToTop(new int[]{1,2}); // copy node 3 and 4
161
162 mergedNodes = inspectNodeList(model, "Merged");
163 assertEquals(3, mergedNodes.size());
164 assertEquals(3, mergedNodes.get(0).getId()); // my node 3 at position 0
165 assertEquals(4, mergedNodes.get(1).getId()); // my node 4 at position 1
166 assertEquals(1, mergedNodes.get(2).getId()); // already merged node 1 at position 2
167
168 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
169 ensureSelected(mergedSelection, 0,1); // first two rows selected
170 }
171
172
173 @Test
174 public void test_copyMyNodesToEnd_1() {
175 NodeListMergeModel model = new NodeListMergeModel();
176
177 Way myWay = new Way(1, 1);
178 myWay.addNode(new Node(2));
179 myWay.addNode(new Node(3));
180 Way theirWay = new Way(1);
181
182 model.populate(myWay, theirWay);
183 model.copyMyToEnd(new int[]{0});
184
185 List<Node> mergedNodes = inspectNodeList(model, "Merged");
186
187 assertEquals(1, mergedNodes.size());
188 assertEquals(2, mergedNodes.get(0).getId());
189
190 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
191 ensureSelected(mergedSelection, 0);
192 }
193
194 @Test
195 public void test_copyMyNodesToEnd_2() {
196 NodeListMergeModel model = new NodeListMergeModel();
197
198 Way myWay = new Way(1, 1);
199 myWay.addNode(new Node(2));
200 myWay.addNode(new Node(3));
201 Way theirWay = new Way(1);
202
203 model.populate(myWay, theirWay);
204
205 List<Node> mergedNodes = inspectNodeList(model, "Merged");
206 mergedNodes.add(new Node(1));
207
208 model.copyMyToEnd(new int[]{0});
209
210 mergedNodes = inspectNodeList(model, "Merged");
211 assertEquals(2, mergedNodes.size());
212 assertEquals(1, mergedNodes.get(0).getId()); // already merged node 1 at position 0
213 assertEquals(2, mergedNodes.get(1).getId()); // copied node 2 at position 1
214
215 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
216 ensureSelected(mergedSelection, 1);
217 }
218
219 @Test
220 public void test_copyMyNodesToEnd_3() {
221 NodeListMergeModel model = new NodeListMergeModel();
222
223
224 Way myWay = new Way(1, 1);
225 myWay.addNode(new Node(2));
226 myWay.addNode(new Node(3));
227 Way theirWay = new Way(1);
228
229 model.populate(myWay, theirWay);
230
231 List<Node> mergedNodes = inspectNodeList(model, "Merged");
232 mergedNodes.add(new Node(1));
233
234 model.copyMyToEnd(new int[]{1}); // copy node 3
235
236 mergedNodes = inspectNodeList(model, "Merged");
237 assertEquals(2, mergedNodes.size());
238 assertEquals(1, mergedNodes.get(0).getId()); // already merged node 1 at position 0
239 assertEquals(3, mergedNodes.get(1).getId()); // my node 3 at position 1
240
241
242 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
243 ensureSelected(mergedSelection, 1);
244 }
245
246 @Test
247 public void test_copyMyNodesToEnd_4() {
248 NodeListMergeModel model = new NodeListMergeModel();
249
250
251 Way myWay = new Way(1, 1);
252 myWay.addNode(new Node(2));
253 myWay.addNode(new Node(3));
254 myWay.addNode(new Node(4));
255 Way theirWay = new Way(1);
256
257 model.populate(myWay, theirWay);
258
259 List<Node> mergedNodes = inspectNodeList(model, "Merged");
260 mergedNodes.add(new Node(1));
261
262 model.copyMyToEnd(new int[]{1,2}); // copy node 3 and 4
263
264 mergedNodes = inspectNodeList(model, "Merged");
265 assertEquals(3, mergedNodes.size());
266 assertEquals(1, mergedNodes.get(0).getId()); // already merged node 1 at position 0
267 assertEquals(3, mergedNodes.get(1).getId()); // my node 3 at position 1
268 assertEquals(4, mergedNodes.get(2).getId()); // my node 4 at position 2
269
270
271 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
272 ensureSelected(mergedSelection, 1,2); // last two rows selected
273 }
274
275 /* ----------------------------------------------------------------------------- */
276 /* copyMyNodesBeforeCurrent */
277 /* ----------------------------------------------------------------------------- */
278
279 @Test
280 public void test_copyMyNodesBeforeCurrent_1() {
281 NodeListMergeModel model = new NodeListMergeModel();
282
283 Way myWay = new Way(1, 1);
284 myWay.addNode(new Node(1));
285 myWay.addNode(new Node(2));
286 Way theirWay = new Way(1);
287
288 model.populate(myWay, theirWay);
289 List<Node> mergedNodes = inspectNodeList(model, "Merged");
290 mergedNodes.add(new Node(10));
291 mergedNodes.add(new Node(11));
292 mergedNodes.add(new Node(12));
293
294 model.copyMyBeforeCurrent(new int[]{0}, 1);
295
296 assertEquals(4, mergedNodes.size());
297 assertEquals(10, mergedNodes.get(0).getId()); // already merged node
298 assertEquals(1, mergedNodes.get(1).getId()); // copied node 1 at position 1
299 assertEquals(11, mergedNodes.get(2).getId()); // already merged node
300 assertEquals(12, mergedNodes.get(3).getId()); // already merged node
301
302 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
303 ensureSelected(mergedSelection, 1); // position 1 selected
304 }
305
306
307 @Test
308 public void test_copyMyNodesBeforeCurrent_2() {
309 NodeListMergeModel model = new NodeListMergeModel();
310
311 Way myWay = new Way(1, 1);
312 myWay.addNode(new Node(1));
313 myWay.addNode(new Node(2));
314 Way theirWay = new Way(1);
315
316 model.populate(myWay, theirWay);
317 List<Node> mergedNodes = inspectNodeList(model, "Merged");
318 mergedNodes.add(new Node(10));
319 mergedNodes.add(new Node(11));
320 mergedNodes.add(new Node(12));
321
322 model.copyMyBeforeCurrent(new int[]{0,1}, 0);
323
324 assertEquals(5, mergedNodes.size());
325 assertEquals(1, mergedNodes.get(0).getId()); // copied node 1 at position 0
326 assertEquals(2, mergedNodes.get(1).getId()); // copied node 2 at position 1
327 assertEquals(10, mergedNodes.get(2).getId()); // already merged node
328 assertEquals(11, mergedNodes.get(3).getId()); // already merged node
329 assertEquals(12, mergedNodes.get(4).getId()); // already merged node
330
331 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
332 ensureSelected(mergedSelection, 0,1); // position 0 and 1 selected
333 }
334
335 @Test
336 public void test_copyMyNodesBeforeCurrent_3() {
337 NodeListMergeModel model = new NodeListMergeModel();
338
339 Way myWay = new Way(1, 1);
340 myWay.addNode(new Node(1));
341 myWay.addNode(new Node(2));
342 Way theirWay = new Way(1);
343
344 model.populate(myWay, theirWay);
345 List<Node> mergedNodes = inspectNodeList(model, "Merged");
346 mergedNodes.add(new Node(10));
347 mergedNodes.add(new Node(11));
348 mergedNodes.add(new Node(12));
349
350 try {
351 model.copyMyBeforeCurrent(new int[]{0,1}, -1);
352 fail("expected IllegalArgumentException");
353 } catch(IllegalArgumentException e) {
354 // OK
355 }
356
357 try {
358 model.copyMyBeforeCurrent(new int[]{0,1}, 3);
359 fail("expected IllegalArgumentException");
360 } catch(IllegalArgumentException e) {
361 // OK
362 }
363 }
364
365 /* ----------------------------------------------------------------------------- */
366 /* copyMyNodesAfterCurrent */
367 /* ----------------------------------------------------------------------------- */
368 @Test
369 public void test_copyMyNodesAfterCurrent_1() {
370 NodeListMergeModel model = new NodeListMergeModel();
371
372 Way myWay = new Way(1, 1);
373 myWay.addNode(new Node(1));
374 myWay.addNode(new Node(2));
375 Way theirWay = new Way(1);
376
377 model.populate(myWay, theirWay);
378 List<Node> mergedNodes = inspectNodeList(model, "Merged");
379 mergedNodes.add(new Node(10));
380 mergedNodes.add(new Node(11));
381 mergedNodes.add(new Node(12));
382
383 model.copyMyAfterCurrent(new int[]{0}, 1);
384
385 assertEquals(4, mergedNodes.size());
386 assertEquals(10, mergedNodes.get(0).getId()); // already merged node
387 assertEquals(11, mergedNodes.get(1).getId()); // already merged node
388 assertEquals(1, mergedNodes.get(2).getId()); // copied node 1 at position 2
389 assertEquals(12, mergedNodes.get(3).getId()); // already merged node
390
391 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
392 ensureSelected(mergedSelection, 2); // position 1 selected
393 }
394
395
396 @Test
397 public void test_copyMyNodesAfterCurrent_2() {
398 NodeListMergeModel model = new NodeListMergeModel();
399
400 Way myWay = new Way(1, 1);
401 myWay.addNode(new Node(1));
402 myWay.addNode(new Node(2));
403 myWay.addNode(new Node(3));
404 Way theirWay = new Way(1);
405
406 model.populate(myWay, theirWay);
407 List<Node> mergedNodes = inspectNodeList(model, "Merged");
408 mergedNodes.add(new Node(10));
409 mergedNodes.add(new Node(11));
410 mergedNodes.add(new Node(12));
411
412 model.copyMyAfterCurrent(new int[]{0,1}, 2);
413
414 assertEquals(5, mergedNodes.size());
415 assertEquals(10, mergedNodes.get(0).getId()); // already merged node
416 assertEquals(11, mergedNodes.get(1).getId()); // already merged node
417 assertEquals(12, mergedNodes.get(2).getId()); // already merged node
418 assertEquals(1, mergedNodes.get(3).getId()); // copied node 1 at position 3
419 assertEquals(2, mergedNodes.get(4).getId()); // copied node 2 at position 4
420
421
422 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
423 ensureSelected(mergedSelection, 3,4); // position 3,4 selected
424 }
425
426 @Test
427 public void test_copyMyNodesAfterCurrent_3() {
428 NodeListMergeModel model = new NodeListMergeModel();
429
430 Way myWay = new Way(1, 1);
431 myWay.addNode(new Node(1));
432 myWay.addNode(new Node(2));
433 myWay.addNode(new Node(3));
434 Way theirWay = new Way(1);
435
436 model.populate(myWay, theirWay);
437 List<Node> mergedNodes = inspectNodeList(model, "Merged");
438 mergedNodes.add(new Node(10));
439 mergedNodes.add(new Node(11));
440 mergedNodes.add(new Node(12));
441
442 model.copyMyAfterCurrent(new int[]{0,2}, 0);
443
444 assertEquals(5, mergedNodes.size());
445 assertEquals(10, mergedNodes.get(0).getId()); // already merged node
446 assertEquals(1, mergedNodes.get(1).getId()); // copied node 1 at position 1
447 assertEquals(3, mergedNodes.get(2).getId()); // copied node 3 at position 2
448 assertEquals(11, mergedNodes.get(3).getId()); // already merged node
449 assertEquals(12, mergedNodes.get(4).getId()); // already merged node
450
451 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
452 ensureSelected(mergedSelection, 1,2); // position 1,2 selected
453 }
454
455 @Test
456 public void test_copyMyNodesAfterCurrent_4() {
457 NodeListMergeModel model = new NodeListMergeModel();
458
459 Way myWay = new Way(1, 1);
460 myWay.addNode(new Node(1));
461 myWay.addNode(new Node(2));
462 Way theirWay = new Way(1);
463
464 model.populate(myWay, theirWay);
465 List<Node> mergedNodes = inspectNodeList(model, "Merged");
466 mergedNodes.add(new Node(10));
467 mergedNodes.add(new Node(11));
468 mergedNodes.add(new Node(12));
469
470 try {
471 model.copyMyAfterCurrent(new int[]{0,1}, -1);
472 fail("expected IllegalArgumentException");
473 } catch(IllegalArgumentException e) {
474 // OK
475 }
476
477 try {
478 model.copyMyAfterCurrent(new int[]{0,1}, 3);
479 fail("expected IllegalArgumentException");
480 } catch(IllegalArgumentException e) {
481 // OK
482 }
483 }
484
485 /* ----------------------------------------------------------------------------- */
486 /* moveUpMergedNodes */
487 /* ----------------------------------------------------------------------------- */
488 @Test
489 public void test_moveUpMergedNodes_1() {
490 NodeListMergeModel model = new NodeListMergeModel();
491
492 Way myWay = new Way(1, 1);
493 myWay.addNode(new Node(1));
494 myWay.addNode(new Node(2));
495 Way theirWay = new Way(1);
496
497 model.populate(myWay, theirWay);
498 List<Node> mergedNodes = inspectNodeList(model, "Merged");
499 mergedNodes.add(new Node(10));
500 mergedNodes.add(new Node(11));
501 mergedNodes.add(new Node(12));
502
503 model.moveUpMerged(new int[]{1});
504
505 assertEquals(3, mergedNodes.size());
506 assertEquals(11, mergedNodes.get(0).getId());
507 assertEquals(10, mergedNodes.get(1).getId());
508 assertEquals(12, mergedNodes.get(2).getId());
509
510 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
511 ensureSelected(mergedSelection, 0); // position 1 selecte0
512 }
513
514 @Test
515 public void test_moveUpMergedNodes_2() {
516 NodeListMergeModel model = new NodeListMergeModel();
517
518 Way myWay = new Way(1, 1);
519 myWay.addNode(new Node(1));
520 myWay.addNode(new Node(2));
521 Way theirWay = new Way(1);
522
523 model.populate(myWay, theirWay);
524 List<Node> mergedNodes = inspectNodeList(model, "Merged");
525 mergedNodes.add(new Node(10));
526 mergedNodes.add(new Node(11));
527 mergedNodes.add(new Node(12));
528 mergedNodes.add(new Node(13));
529 mergedNodes.add(new Node(14));
530
531 model.moveUpMerged(new int[]{1,4});
532
533 assertEquals(5, mergedNodes.size());
534 assertEquals(11, mergedNodes.get(0).getId());
535 assertEquals(10, mergedNodes.get(1).getId());
536 assertEquals(12, mergedNodes.get(2).getId());
537 assertEquals(14, mergedNodes.get(3).getId());
538 assertEquals(13, mergedNodes.get(4).getId());
539
540 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
541 ensureSelected(mergedSelection, 0,3); // position 0 and 3 selecte0
542 }
543
544 @Test
545 public void test_moveUpMergedNodes_3() {
546 NodeListMergeModel model = new NodeListMergeModel();
547
548 Way myWay = new Way(1, 1);
549 myWay.addNode(new Node(1));
550 myWay.addNode(new Node(2));
551 Way theirWay = new Way(1);
552
553 model.populate(myWay, theirWay);
554 List<Node> mergedNodes = inspectNodeList(model, "Merged");
555 mergedNodes.add(new Node(10));
556 mergedNodes.add(new Node(11));
557 mergedNodes.add(new Node(12));
558 mergedNodes.add(new Node(13));
559 mergedNodes.add(new Node(14));
560
561 model.moveUpMerged(new int[]{1,2,3,4});
562
563 assertEquals(5, mergedNodes.size());
564 assertEquals(11, mergedNodes.get(0).getId());
565 assertEquals(12, mergedNodes.get(1).getId());
566 assertEquals(13, mergedNodes.get(2).getId());
567 assertEquals(14, mergedNodes.get(3).getId());
568 assertEquals(10, mergedNodes.get(4).getId());
569
570 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
571 ensureSelected(mergedSelection, 0,1,2,3);
572 }
573
574 /* ----------------------------------------------------------------------------- */
575 /* moveDownMergedNodes */
576 /* ----------------------------------------------------------------------------- */
577 @Test
578 public void test_moveDownMergedNodes_1() {
579 NodeListMergeModel model = new NodeListMergeModel();
580
581 Way myWay = new Way(1, 1);
582 myWay.addNode(new Node(1));
583 myWay.addNode(new Node(2));
584 Way theirWay = new Way(1);
585
586 model.populate(myWay, theirWay);
587 List<Node> mergedNodes = inspectNodeList(model, "Merged");
588 mergedNodes.add(new Node(10));
589 mergedNodes.add(new Node(11));
590 mergedNodes.add(new Node(12));
591
592 model.moveDownMerged(new int[]{1});
593
594 assertEquals(3, mergedNodes.size());
595 assertEquals(10, mergedNodes.get(0).getId());
596 assertEquals(12, mergedNodes.get(1).getId());
597 assertEquals(11, mergedNodes.get(2).getId());
598
599 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
600 ensureSelected(mergedSelection, 2);
601 }
602
603 @Test
604 public void test_moveDownMergedNodes_2() {
605 NodeListMergeModel model = new NodeListMergeModel();
606
607 Way myWay = new Way(1, 1);
608 myWay.addNode(new Node(1));
609 myWay.addNode(new Node(2));
610 Way theirWay = new Way(1);
611
612 model.populate(myWay, theirWay);
613 List<Node> mergedNodes = inspectNodeList(model, "Merged");
614 mergedNodes.add(new Node(10));
615 mergedNodes.add(new Node(11));
616 mergedNodes.add(new Node(12));
617 mergedNodes.add(new Node(13));
618 mergedNodes.add(new Node(14));
619
620 model.moveDownMerged(new int[]{1,3});
621
622 assertEquals(5, mergedNodes.size());
623 assertEquals(10, mergedNodes.get(0).getId());
624 assertEquals(12, mergedNodes.get(1).getId());
625 assertEquals(11, mergedNodes.get(2).getId());
626 assertEquals(14, mergedNodes.get(3).getId());
627 assertEquals(13, mergedNodes.get(4).getId());
628
629 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
630 ensureSelected(mergedSelection, 2,4);
631 }
632
633 @Test
634 public void test_moveDownMergedNodes_3() {
635 NodeListMergeModel model = new NodeListMergeModel();
636
637 Way myWay = new Way(1, 1);
638 myWay.addNode(new Node(1));
639 myWay.addNode(new Node(2));
640 Way theirWay = new Way(1);
641
642 model.populate(myWay, theirWay);
643 List<Node> mergedNodes = inspectNodeList(model, "Merged");
644 mergedNodes.add(new Node(10));
645 mergedNodes.add(new Node(11));
646 mergedNodes.add(new Node(12));
647 mergedNodes.add(new Node(13));
648 mergedNodes.add(new Node(14));
649
650 model.moveDownMerged(new int[]{1,2,3});
651
652 assertEquals(5, mergedNodes.size());
653 assertEquals(10, mergedNodes.get(0).getId());
654 assertEquals(14, mergedNodes.get(1).getId());
655 assertEquals(11, mergedNodes.get(2).getId());
656 assertEquals(12, mergedNodes.get(3).getId());
657 assertEquals(13, mergedNodes.get(4).getId());
658
659 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
660 ensureSelected(mergedSelection, 2,3,4);
661 }
662
663 /* ----------------------------------------------------------------------------- */
664 /* PropertyChangeListener */
665 /* ----------------------------------------------------------------------------- */
666 @Test
667 public void addPropertyChangeListener() {
668 NodeListMergeModel model = new NodeListMergeModel();
669
670 PropertyChangeListener listener = new PropertyChangeListener() {
671
672 public void propertyChange(PropertyChangeEvent evt) {
673 }
674 };
675
676 model.addPropertyChangeListener(listener);
677
678 ArrayList<PropertyChangeListener> listeners = field("listeners")
679 .ofType(ArrayList.class)
680 .in(model)
681 .get();
682
683 assertEquals(1, listeners.size());
684 assertEquals(listener, listeners.get(0));
685 }
686
687 @Test
688 public void removePropertyChangeListener() {
689 NodeListMergeModel model = new NodeListMergeModel();
690
691 PropertyChangeListener listener = new PropertyChangeListener() {
692
693 public void propertyChange(PropertyChangeEvent evt) {
694 }
695 };
696
697 model.addPropertyChangeListener(listener);
698 model.removePropertyChangeListener(listener);
699
700 ArrayList<PropertyChangeListener> listeners = field("listeners")
701 .ofType(ArrayList.class)
702 .in(model)
703 .get();
704
705 assertEquals(0, listeners.size());
706 }
707
708 /* ----------------------------------------------------------------------------- */
709 /* property frozen */
710 /* ----------------------------------------------------------------------------- */
711 @Test
712 public void setFrozen() {
713 NodeListMergeModel model = new NodeListMergeModel();
714 model.setFrozen(true);
715 assertTrue(model.isFrozen());
716
717 model.setFrozen(false);
718 assertTrue(!model.isFrozen());
719 }
720
721 @Test
722 public void setFrozenWithPropertyChangeNotification() {
723 NodeListMergeModel model = new NodeListMergeModel();
724
725 class MyListener implements PropertyChangeListener {
726 public ArrayList<PropertyChangeEvent> events = new ArrayList<PropertyChangeEvent>();
727
728 public void propertyChange(PropertyChangeEvent evt) {
729 events.add(evt);
730 }
731 };
732 MyListener listener = new MyListener();
733 model.addPropertyChangeListener(listener);
734 boolean oldValue = model.isFrozen();
735 model.setFrozen(!oldValue);
736 assertEquals(!oldValue, model.isFrozen());
737
738 assertEquals(1, listener.events.size());
739 assertEquals(oldValue, listener.events.get(0).getOldValue());
740 assertEquals(!oldValue, listener.events.get(0).getNewValue());
741 }
742
743}
Note: See TracBrowser for help on using the repository browser.