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

Last change on this file since 9504 was 8857, checked in by Don-vip, 9 years ago

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