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

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

see #13232 - move class DatasetFactory to unit tests folder
  • Property svn:eol-style set to native
File size: 26.3 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.gui.conflict.pair.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.assertFalse;
8import static org.junit.Assert.assertTrue;
9import static org.junit.Assert.fail;
10
11import java.beans.PropertyChangeEvent;
12import java.beans.PropertyChangeListener;
13import java.util.ArrayList;
14import java.util.Arrays;
15import java.util.List;
16import java.util.Set;
17
18import javax.swing.DefaultListSelectionModel;
19
20import org.junit.BeforeClass;
21import org.junit.Test;
22import org.openstreetmap.josm.JOSMFixture;
23import org.openstreetmap.josm.Main;
24import org.openstreetmap.josm.data.osm.Node;
25import org.openstreetmap.josm.data.osm.Way;
26import org.openstreetmap.josm.testutils.DatasetFactory;
27
28public class NodeListMergeModelTest {
29
30 private DatasetFactory my = new DatasetFactory();
31 private DatasetFactory their = new DatasetFactory();
32
33 /**
34 * Setup test.
35 */
36 @BeforeClass
37 public static void init() {
38 JOSMFixture.createUnitTestFixture().init();
39 }
40
41 @SuppressWarnings("unchecked")
42 protected List<Node> inspectNodeList(NodeListMergeModel model, String name) {
43 return method("get" + name + "Entries")
44 .withReturnType(List.class)
45 .in(model)
46 .invoke();
47 }
48
49 protected DefaultListSelectionModel inspectListSelectionModel(NodeListMergeModel model, String name) {
50 return field(name).ofType(DefaultListSelectionModel.class)
51 .in(model)
52 .get();
53 }
54
55 protected void ensureSelected(DefaultListSelectionModel model, Object... idx) {
56 if (idx == null) return;
57 for (int i = 0; i < idx.length; i++) {
58 if (idx[i] instanceof Integer) {
59 int j = (Integer) idx[i];
60 assertTrue("expected row " + j + " to be selected", model.isSelectedIndex(j));
61 break;
62 }
63 try {
64 int[] rows = (int[]) idx[i];
65 if (rows.length != 2) {
66 fail("illegal selection range. Either null or not length 2: " + Arrays.toString(rows));
67 }
68 if (rows[0] > rows[1]) {
69 fail("illegal selection range. lower bound > upper bound ");
70 }
71 for (int j = rows[0]; j <= rows[1]; j++) {
72 assertTrue("expected row " + j + " to be selected", model.isSelectedIndex(j));
73 }
74 } catch (ClassCastException e) {
75 fail("illegal selection range:" + idx[i]);
76 }
77 }
78 }
79
80 @Test
81 public void testCopyMyNodesToTop1() {
82 NodeListMergeModel model = new NodeListMergeModel();
83
84 Way myWay = my.addWay(1, 1);
85 myWay.addNode(my.addNode(2));
86 myWay.addNode(my.addNode(3));
87
88 Way theirWay = their.addWay(1);
89
90 model.populate(myWay, theirWay, null);
91 model.copyMyToTop(new int[]{0});
92
93 List<Node> mergedNodes = inspectNodeList(model, "Merged");
94
95 assertEquals(1, mergedNodes.size());
96 assertEquals(2, mergedNodes.get(0).getId());
97
98 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
99 ensureSelected(mergedSelection, 0);
100 }
101
102 @Test
103 public void testCopyMyNodesToTop2() {
104 NodeListMergeModel model = new NodeListMergeModel();
105
106 Way myWay = my.addWay(1, 1);
107 myWay.addNode(my.addNode(2));
108 myWay.addNode(my.addNode(3));
109
110 Way theirWay = their.addWay(1);
111
112 model.populate(myWay, theirWay, null);
113
114 List<Node> mergedNodes = inspectNodeList(model, "Merged");
115 mergedNodes.add(new Node(1));
116
117 model.copyMyToTop(new int[]{0});
118
119 mergedNodes = inspectNodeList(model, "Merged");
120 assertEquals(2, mergedNodes.size());
121 assertEquals(2, mergedNodes.get(0).getId());
122 assertEquals(1, mergedNodes.get(1).getId());
123
124 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
125 ensureSelected(mergedSelection, 0);
126 }
127
128 @Test
129 public void testCopyMyNodesToTop3() {
130 NodeListMergeModel model = new NodeListMergeModel();
131
132 Way myWay = my.addWay(1, 1);
133 myWay.addNode(my.addNode(2));
134 myWay.addNode(my.addNode(3));
135 Way theirWay = their.addWay(1);
136
137
138 model.populate(myWay, theirWay, null);
139
140 List<Node> mergedNodes = inspectNodeList(model, "Merged");
141 mergedNodes.add(new Node(1));
142
143 model.copyMyToTop(new int[]{1}); // copy node 3
144
145 mergedNodes = inspectNodeList(model, "Merged");
146 assertEquals(2, mergedNodes.size());
147 assertEquals(3, mergedNodes.get(0).getId()); // my node 3 at position 0
148 assertEquals(1, mergedNodes.get(1).getId()); // already merged node 1 at position 1
149
150 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
151 ensureSelected(mergedSelection, 0);
152 }
153
154 @Test
155 public void testCopyMyNodesToTop4() {
156 NodeListMergeModel model = new NodeListMergeModel();
157
158 Way myWay = my.addWay(1, 1);
159 myWay.addNode(my.addNode(2));
160 myWay.addNode(my.addNode(3));
161 myWay.addNode(my.addNode(4));
162 Way theirWay = their.addWay(1);
163
164 model.populate(myWay, theirWay, null);
165
166 List<Node> mergedNodes = inspectNodeList(model, "Merged");
167 mergedNodes.add(new Node(1));
168
169 model.copyMyToTop(new int[]{1, 2}); // copy node 3 and 4
170
171 mergedNodes = inspectNodeList(model, "Merged");
172 assertEquals(3, mergedNodes.size());
173 assertEquals(3, mergedNodes.get(0).getId()); // my node 3 at position 0
174 assertEquals(4, mergedNodes.get(1).getId()); // my node 4 at position 1
175 assertEquals(1, mergedNodes.get(2).getId()); // already merged node 1 at position 2
176
177 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
178 ensureSelected(mergedSelection, 0, 1); // first two rows selected
179 }
180
181 @Test
182 public void testCopyMyNodesToEnd1() {
183 NodeListMergeModel model = new NodeListMergeModel();
184
185 Way myWay = my.addWay(1, 1);
186 myWay.addNode(my.addNode(2));
187 myWay.addNode(my.addNode(3));
188 Way theirWay = their.addWay(1);
189
190 model.populate(myWay, theirWay, null);
191 model.copyMyToEnd(new int[]{0});
192
193 List<Node> mergedNodes = inspectNodeList(model, "Merged");
194
195 assertEquals(1, mergedNodes.size());
196 assertEquals(2, mergedNodes.get(0).getId());
197
198 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
199 ensureSelected(mergedSelection, 0);
200 }
201
202 @Test
203 public void testCopyMyNodesToEnd2() {
204 NodeListMergeModel model = new NodeListMergeModel();
205
206 Way myWay = my.addWay(1, 1);
207 myWay.addNode(my.addNode(2));
208 myWay.addNode(my.addNode(3));
209 Way theirWay = their.addWay(1);
210
211 model.populate(myWay, theirWay, null);
212
213 List<Node> mergedNodes = inspectNodeList(model, "Merged");
214 mergedNodes.add(new Node(1));
215
216 model.copyMyToEnd(new int[]{0});
217
218 mergedNodes = inspectNodeList(model, "Merged");
219 assertEquals(2, mergedNodes.size());
220 assertEquals(1, mergedNodes.get(0).getId()); // already merged node 1 at position 0
221 assertEquals(2, mergedNodes.get(1).getId()); // copied node 2 at position 1
222
223 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
224 ensureSelected(mergedSelection, 1);
225 }
226
227 @Test
228 public void testCopyMyNodesToEnd3() {
229 NodeListMergeModel model = new NodeListMergeModel();
230
231
232 Way myWay = my.addWay(1, 1);
233 myWay.addNode(my.addNode(2));
234 myWay.addNode(my.addNode(3));
235 Way theirWay = their.addWay(1);
236
237 model.populate(myWay, theirWay, null);
238
239 List<Node> mergedNodes = inspectNodeList(model, "Merged");
240 mergedNodes.add(new Node(1));
241
242 model.copyMyToEnd(new int[]{1}); // copy node 3
243
244 mergedNodes = inspectNodeList(model, "Merged");
245 assertEquals(2, mergedNodes.size());
246 assertEquals(1, mergedNodes.get(0).getId()); // already merged node 1 at position 0
247 assertEquals(3, mergedNodes.get(1).getId()); // my node 3 at position 1
248
249
250 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
251 ensureSelected(mergedSelection, 1);
252 }
253
254 @Test
255 public void testCopyMyNodesToEnd4() {
256 NodeListMergeModel model = new NodeListMergeModel();
257
258
259 Way myWay = my.addWay(1, 1);
260 myWay.addNode(my.addNode(2));
261 myWay.addNode(my.addNode(3));
262 myWay.addNode(my.addNode(4));
263 Way theirWay = their.addWay(1);
264
265 model.populate(myWay, theirWay, null);
266
267 List<Node> mergedNodes = inspectNodeList(model, "Merged");
268 mergedNodes.add(new Node(1));
269
270 model.copyMyToEnd(new int[]{1, 2}); // copy node 3 and 4
271
272 mergedNodes = inspectNodeList(model, "Merged");
273 assertEquals(3, mergedNodes.size());
274 assertEquals(1, mergedNodes.get(0).getId()); // already merged node 1 at position 0
275 assertEquals(3, mergedNodes.get(1).getId()); // my node 3 at position 1
276 assertEquals(4, mergedNodes.get(2).getId()); // my node 4 at position 2
277
278
279 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
280 ensureSelected(mergedSelection, 1, 2); // last two rows selected
281 }
282
283 /* ----------------------------------------------------------------------------- */
284 /* copyMyNodesBeforeCurrent */
285 /* ----------------------------------------------------------------------------- */
286
287 @Test
288 public void testCopyMyNodesBeforeCurrent1() {
289 NodeListMergeModel model = new NodeListMergeModel();
290
291 Way myWay = my.addWay(1, 1);
292 myWay.addNode(my.addNode(1));
293 myWay.addNode(my.addNode(2));
294 Way theirWay = their.addWay(1);
295
296 model.populate(myWay, theirWay, null);
297 List<Node> mergedNodes = inspectNodeList(model, "Merged");
298 mergedNodes.add(new Node(10));
299 mergedNodes.add(new Node(11));
300 mergedNodes.add(new Node(12));
301
302 model.copyMyBeforeCurrent(new int[]{0}, 1);
303
304 assertEquals(4, mergedNodes.size());
305 assertEquals(10, mergedNodes.get(0).getId()); // already merged node
306 assertEquals(1, mergedNodes.get(1).getId()); // copied node 1 at position 1
307 assertEquals(11, mergedNodes.get(2).getId()); // already merged node
308 assertEquals(12, mergedNodes.get(3).getId()); // already merged node
309
310 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
311 ensureSelected(mergedSelection, 1); // position 1 selected
312 }
313
314 @Test
315 public void testCopyMyNodesBeforeCurrent2() {
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 testCopyMyNodesBeforeCurrent3() {
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 Main.trace(e);
363 }
364
365 try {
366 model.copyMyBeforeCurrent(new int[]{0, 1}, 4);
367 fail("expected IllegalArgumentException");
368 } catch (IllegalArgumentException e) {
369 // OK
370 Main.trace(e);
371 }
372 }
373
374 /* ----------------------------------------------------------------------------- */
375 /* copyMyNodesAfterCurrent */
376 /* ----------------------------------------------------------------------------- */
377 @Test
378 public void testCopyMyNodesAfterCurrent1() {
379 NodeListMergeModel model = new NodeListMergeModel();
380
381 Way myWay = my.addWay(1, 1);
382 myWay.addNode(my.addNode(1));
383 myWay.addNode(my.addNode(2));
384 Way theirWay = their.addWay(1);
385
386 model.populate(myWay, theirWay, null);
387 List<Node> mergedNodes = inspectNodeList(model, "Merged");
388 mergedNodes.add(new Node(10));
389 mergedNodes.add(new Node(11));
390 mergedNodes.add(new Node(12));
391
392 model.copyMyAfterCurrent(new int[]{0}, 1);
393
394 assertEquals(4, mergedNodes.size());
395 assertEquals(10, mergedNodes.get(0).getId()); // already merged node
396 assertEquals(11, mergedNodes.get(1).getId()); // already merged node
397 assertEquals(1, mergedNodes.get(2).getId()); // copied node 1 at position 2
398 assertEquals(12, mergedNodes.get(3).getId()); // already merged node
399
400 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
401 ensureSelected(mergedSelection, 2); // position 1 selected
402 }
403
404 @Test
405 public void testCopyMyNodesAfterCurrent2() {
406 NodeListMergeModel model = new NodeListMergeModel();
407
408 Way myWay = my.addWay(1, 1);
409 myWay.addNode(my.addNode(1));
410 myWay.addNode(my.addNode(2));
411 myWay.addNode(my.addNode(3));
412 Way theirWay = their.addWay(1);
413
414 model.populate(myWay, theirWay, null);
415 List<Node> mergedNodes = inspectNodeList(model, "Merged");
416 mergedNodes.add(new Node(10));
417 mergedNodes.add(new Node(11));
418 mergedNodes.add(new Node(12));
419
420 model.copyMyAfterCurrent(new int[]{0, 1}, 2);
421
422 assertEquals(5, mergedNodes.size());
423 assertEquals(10, mergedNodes.get(0).getId()); // already merged node
424 assertEquals(11, mergedNodes.get(1).getId()); // already merged node
425 assertEquals(12, mergedNodes.get(2).getId()); // already merged node
426 assertEquals(1, mergedNodes.get(3).getId()); // copied node 1 at position 3
427 assertEquals(2, mergedNodes.get(4).getId()); // copied node 2 at position 4
428
429 DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
430 ensureSelected(mergedSelection, 3, 4); // position 3,4 selected
431 }
432
433 @Test
434 public void testCopyMyNodesAfterCurrent3() {
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 testMoveUpMergedNodes1() {
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 testMoveUpMergedNodes2() {
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 testMoveUpMergedNodes3() {
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 testMoveDownMergedNodes1() {
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 testMoveDownMergedNodes2() {
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 testMoveDownMergedNodes3() {
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 testAddPropertyChangeListener() {
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 Set<PropertyChangeListener> listeners = field("listeners")
658 .ofType(Set.class)
659 .in(model)
660 .get();
661
662 assertEquals(1, listeners.size());
663 assertEquals(listener, listeners.iterator().next());
664 }
665
666 @SuppressWarnings("unchecked")
667 @Test
668 public void testRemovePropertyChangeListener() {
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 Set<PropertyChangeListener> listeners = field("listeners")
681 .ofType(Set.class)
682 .in(model)
683 .get();
684
685 assertEquals(0, listeners.size());
686 }
687
688 /* ----------------------------------------------------------------------------- */
689 /* property frozen */
690 /* ----------------------------------------------------------------------------- */
691 @Test
692 public void testSetFrozen() {
693 NodeListMergeModel model = new NodeListMergeModel();
694 model.setFrozen(true);
695 assertTrue(model.isFrozen());
696
697 model.setFrozen(false);
698 assertFalse(model.isFrozen());
699 }
700
701 @Test
702 public void testSetFrozenWithPropertyChangeNotification() {
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
713 MyListener listener = new MyListener();
714 model.addPropertyChangeListener(listener);
715 boolean oldValue = model.isFrozen();
716 model.setFrozen(!oldValue);
717 assertEquals(!oldValue, model.isFrozen());
718
719 assertEquals(1, listener.events.size());
720 assertEquals(oldValue, listener.events.get(0).getOldValue());
721 assertEquals(!oldValue, listener.events.get(0).getNewValue());
722 }
723}
Note: See TracBrowser for help on using the repository browser.