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

Last change on this file since 7081 was 7081, checked in by Don-vip, 10 years ago

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