source: josm/trunk/test/unit/org/openstreetmap/josm/data/osm/visitor/MergeVisitorTest.java@ 1750

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

new: replaced global conflict list by conflict list per layer, similar to datasets

File size: 24.1 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.data.osm.visitor;
3
4import static org.junit.Assert.assertEquals;
5import static org.junit.Assert.assertTrue;
6import static org.junit.Assert.fail;
7
8import java.io.File;
9import java.text.MessageFormat;
10import java.util.Calendar;
11import java.util.Date;
12import java.util.GregorianCalendar;
13import java.util.Properties;
14import java.util.logging.Level;
15import java.util.logging.Logger;
16
17import org.junit.BeforeClass;
18import org.junit.Test;
19import org.openstreetmap.josm.Main;
20import org.openstreetmap.josm.data.coor.LatLon;
21import org.openstreetmap.josm.data.osm.DataSet;
22import org.openstreetmap.josm.data.osm.Node;
23import org.openstreetmap.josm.data.osm.User;
24import org.openstreetmap.josm.data.osm.Way;
25import org.openstreetmap.josm.data.projection.Mercator;
26import org.openstreetmap.josm.gui.PleaseWaitDialog;
27
28public class MergeVisitorTest {
29 private static Logger logger = Logger.getLogger(MergeVisitorTest.class.getName());
30
31 static Properties testProperties;
32
33 @BeforeClass
34 static public void init() {
35 testProperties = new Properties();
36
37 // load properties
38 //
39 try {
40 testProperties.load(MergeVisitorTest.class.getResourceAsStream("/test-unit-env.properties"));
41 } catch(Exception e){
42 logger.log(Level.SEVERE, MessageFormat.format("failed to load property file ''{0}''", "/test-unit-env.properties"));
43 fail(MessageFormat.format("failed to load property file ''{0}''", "/test-unit-env.properties"));
44 }
45
46 // check josm.home
47 //
48 String josmHome = testProperties.getProperty("josm.home");
49 if (josmHome == null) {
50 fail(MessageFormat.format("property ''{0}'' not set in test environment", "josm.home"));
51 } else {
52 File f = new File(josmHome);
53 if (! f.exists() || ! f.canRead()) {
54 fail(MessageFormat.format("property ''{0}'' points to ''{1}'' which is either not existing or not readable", "josm.home", josmHome));
55 }
56 }
57 System.setProperty("josm.home", josmHome);
58 Main.pleaseWaitDlg = new PleaseWaitDialog(null);
59 Main.pref.init(false);
60
61 // init projection
62 Main.proj = new Mercator();
63 }
64
65 /**
66 * two identical nodes, even in id and version. No confict expected.
67 *
68 * Can happen if data is loaded in two layers and then merged from one layer
69 * on the other.
70 */
71 @Test
72 public void nodeSimple_IdenticalNoConflict() {
73 DataSet my = new DataSet();
74 my.version = "0.6";
75 Node n = new Node(new LatLon(0,0));
76 n.id = 1;
77 n.version = 1;
78 n.modified = false;
79 n.put("key1", "value1");
80 my.addPrimitive(n);
81
82 DataSet their = new DataSet();
83 their.version = "0.6";
84 Node n1 = new Node(new LatLon(0,0));
85 n1.id = 1;
86 n1.version = 1;
87 n1.modified = false;
88 n1.put("key1", "value1");
89 their.addPrimitive(n1);
90
91
92 MergeVisitor visitor = new MergeVisitor(my,their);
93 visitor.merge();
94
95 Node n2 = (Node)my.getPrimitiveById(1);
96 assertTrue(visitor.getConflicts().isEmpty());
97 assertEquals(1, n2.id);
98 assertEquals(1, n2.version);
99 assertEquals(false, n2.modified);
100 assertEquals("value1", n2.get("key1"));
101 }
102
103 /**
104 * two nodes, my is unmodified, their is updated and has a higher version
105 * => their version is going to be the merged version
106 *
107 */
108 @Test
109 public void nodeSimple_locallyUnmodifiedNoConflict() {
110 DataSet my = new DataSet();
111 my.version = "0.6";
112 Node n = new Node(new LatLon(0,0));
113 n.id = 1;
114 n.version = 1;
115 n.modified = false;
116 n.put("key1", "value1");
117 my.addPrimitive(n);
118
119 DataSet their = new DataSet();
120 their.version = "0.6";
121 Node n1 = new Node(new LatLon(0,0));
122 n1.id = 1;
123 n1.version = 2;
124 n1.modified = false;
125 n1.put("key1", "value1-new");
126 n1.put("key2", "value2");
127 their.addPrimitive(n1);
128
129
130 MergeVisitor visitor = new MergeVisitor(my,their);
131 visitor.merge();
132
133 Node n2 = (Node)my.getPrimitiveById(1);
134 assertTrue(visitor.getConflicts().isEmpty());
135 assertEquals(1, n2.id);
136 assertEquals(2, n2.version);
137 assertEquals(false, n2.modified);
138 assertEquals("value1-new", n2.get("key1"));
139 assertEquals("value2", n2.get("key2"));
140 }
141
142 /**
143 * node with same id, my is modified, their has a higher version
144 * => results in a conflict
145 *
146 * Use case: node which is modified locally and updated by another mapper on
147 * the server
148 */
149 @Test
150 public void nodeSimple_TagConflict() {
151 DataSet my = new DataSet();
152 my.version = "0.6";
153 Node n = new Node(new LatLon(0,0));
154 n.id = 1;
155 n.version = 1;
156 n.modified = true;
157 n.put("key1", "value1");
158 n.put("key2", "value2");
159 my.addPrimitive(n);
160
161 DataSet their = new DataSet();
162 their.version = "0.6";
163 Node n1 = new Node(new LatLon(0,0));
164 n1.id = 1;
165 n1.version = 2;
166 n1.modified = false;
167 n1.put("key1", "value1-new");
168
169 their.addPrimitive(n1);
170
171
172 MergeVisitor visitor = new MergeVisitor(my,their);
173 visitor.merge();
174
175 Node n2 = (Node)my.getPrimitiveById(1);
176 assertEquals(1,visitor.getConflicts().size());
177 assertEquals(n, n2);
178 }
179
180 /**
181 * node with same id, my is deleted, their has a higher version
182 * => results in a conflict
183 *
184 * Use case: node which is deleted locally and updated by another mapper on
185 * the server
186 */
187 @Test
188 public void nodeSimple_DeleteConflict() {
189 DataSet my = new DataSet();
190 my.version = "0.6";
191 Node n = new Node(new LatLon(0,0));
192 n.id = 1;
193 n.delete(true);
194 n.put("key1", "value1");
195 my.addPrimitive(n);
196
197 DataSet their = new DataSet();
198 their.version = "0.6";
199 Node n1 = new Node(new LatLon(0,0));
200 n1.id = 1;
201 n1.version = 2;
202 n1.modified = false;
203 n1.put("key1", "value1-new");
204 n1.put("key2", "value2");
205 their.addPrimitive(n1);
206
207
208 MergeVisitor visitor = new MergeVisitor(my,their);
209 visitor.merge();
210
211 Node n2 = (Node)my.getPrimitiveById(1);
212 assertEquals(1,visitor.getConflicts().size());
213 assertEquals(n, n2);
214 }
215
216 /**
217 * My node is visible, their version has a higher version and is not visible
218 * => create a conflict
219 *
220 */
221 @Test
222 public void nodeSimple_VisibleConflict() {
223 DataSet my = new DataSet();
224 my.version = "0.6";
225 Node n = new Node(new LatLon(0,0));
226 n.id = 1;
227 n.version = 1;
228 n.modified = false;
229 n.visible = true;
230 my.addPrimitive(n);
231
232 DataSet their = new DataSet();
233 their.version = "0.6";
234 Node n1 = new Node(new LatLon(0,0));
235 n1.id = 1;
236 n1.version = 2;
237 n1.modified = false;
238 n1.visible = false;
239 their.addPrimitive(n1);
240
241
242 MergeVisitor visitor = new MergeVisitor(my,their);
243 visitor.merge();
244
245 Node n2 = (Node)my.getPrimitiveById(1);
246 assertEquals(1,visitor.getConflicts().size());
247 assertEquals(true, n2.visible);
248 }
249
250 /**
251 * My node is deleted, their node has the same id and version and is not deleted.
252 * => mine has precedence
253 *
254 */
255 @Test
256 public void nodeSimple_DeleteConflict_2() {
257 DataSet my = new DataSet();
258 my.version = "0.6";
259 Node n = new Node(new LatLon(0,0));
260 n.id = 1;
261 n.version = 1;
262 n.delete(true);
263 my.addPrimitive(n);
264
265 DataSet their = new DataSet();
266 their.version = "0.6";
267 Node n1 = new Node(new LatLon(0,0));
268 n1.id = 1;
269 n1.version = 1;
270 their.addPrimitive(n1);
271
272
273 MergeVisitor visitor = new MergeVisitor(my,their);
274 visitor.merge();
275
276 Node n2 = (Node)my.getPrimitiveById(1);
277 assertEquals(0,visitor.getConflicts().size());
278 assertEquals(true, n2.visible);
279 }
280
281 /**
282 * My and their node are new but semantically equal. My node is deleted.
283 *
284 * => create a conflict
285 *
286 */
287 @Test
288 public void nodeSimple_DeleteConflict_3() {
289 DataSet my = new DataSet();
290 my.version = "0.6";
291 Node n = new Node(new LatLon(1,1));
292 n.id = 0;
293 n.delete(true);
294 my.addPrimitive(n);
295
296 DataSet their = new DataSet();
297 their.version = "0.6";
298 Node n1 = new Node(new LatLon(1,1));
299 n1.id = 0;
300 their.addPrimitive(n1);
301
302
303 MergeVisitor visitor = new MergeVisitor(my,their);
304 visitor.merge();
305
306 assertEquals(1,visitor.getConflicts().size());
307 }
308
309 /**
310 * My and their node are new but semantically equal. Both are deleted.
311 *
312 * => take mine
313 *
314 */
315 @Test
316 public void nodeSimple_DeleteConflict_4() {
317 DataSet my = new DataSet();
318 my.version = "0.6";
319 Node n = new Node(new LatLon(1,1));
320 n.id = 0;
321 n.delete(true);
322 my.addPrimitive(n);
323
324 DataSet their = new DataSet();
325 their.version = "0.6";
326 Node n1 = new Node(new LatLon(1,1));
327 n1.id = 0;
328 n1.delete(true);
329 their.addPrimitive(n1);
330
331
332 MergeVisitor visitor = new MergeVisitor(my,their);
333 visitor.merge();
334
335 assertEquals(0,visitor.getConflicts().size());
336 }
337
338 /**
339 * their node is not visible and doesn't exist in my data set
340 * => ignore their node
341 *
342 */
343 @Test
344 public void nodeSimple_InvisibleNodeInTheirDataset() {
345 DataSet my = new DataSet();
346 my.version = "0.6";
347 Node n = new Node(new LatLon(0,0));
348 n.id = 1;
349 n.version = 1;
350 n.delete(true);
351 my.addPrimitive(n);
352
353 DataSet their = new DataSet();
354 their.version = "0.6";
355 Node n1 = new Node(new LatLon(0,0));
356 n1.id = 2;
357 n1.version = 1;
358 n1.visible = false;
359 their.addPrimitive(n1);
360
361
362 MergeVisitor visitor = new MergeVisitor(my,their);
363 visitor.merge();
364
365 Node n2 = (Node)my.getPrimitiveById(1);
366 assertEquals(0,visitor.getConflicts().size());
367 assertEquals(2,my.nodes.size());
368 assertEquals(n,n2);
369 }
370
371 /**
372 * their node has no assigned id (id == 0) and is semantically equal to one of my
373 * nodes with id == 0
374 *
375 * => merge it onto my node.
376 *
377 */
378 @Test
379 public void nodeSimple_NoIdSemanticallyEqual() {
380
381 Calendar cal = GregorianCalendar.getInstance();
382 User myUser = User.get("my");
383 myUser.uid = "1111";
384
385 User theirUser = User.get("their");
386 myUser.uid = "222";
387
388 DataSet my = new DataSet();
389 my.version = "0.6";
390 Node n = new Node(new LatLon(0,0));
391 n.id = 0;
392 n.version = -1;
393 n.put("key1", "value1");
394 n.user = myUser;
395 n.setTimestamp(cal.getTime());
396
397 my.addPrimitive(n);
398
399 DataSet their = new DataSet();
400 their.version = "0.6";
401 Node n1 = new Node(new LatLon(0,0));
402 n1.id = 0;
403 n1.version = -1;
404 n1.put("key1", "value1");
405 cal.add(Calendar.HOUR, 1);
406 Date timestamp = cal.getTime();
407 n1.setTimestamp(timestamp);
408 n1.user = theirUser;
409 their.addPrimitive(n1);
410
411
412 MergeVisitor visitor = new MergeVisitor(my,their);
413 visitor.merge();
414
415 Node n2 = my.nodes.iterator().next();
416 assertEquals(0,visitor.getConflicts().size());
417 assertEquals("value1",n2.get("key1"));
418 assertEquals(true, n1.getTimestamp().equals(n2.getTimestamp()));
419 assertEquals(theirUser,n2.user);
420 }
421
422 /**
423 * my node is incomplete, their node is complete
424 *
425 * => merge it onto my node. My node becomes complete
426 *
427 */
428 @Test
429 public void nodeSimple_IncompleteNode() {
430
431 DataSet my = new DataSet();
432 my.version = "0.6";
433 Node n = new Node(new LatLon(0,0));
434 n.id = 1;
435 n.version = 1;
436 n.incomplete = true;
437 my.addPrimitive(n);
438
439 DataSet their = new DataSet();
440 their.version = "0.6";
441 Node n1 = new Node(new LatLon(0,0));
442 n1.id = 1;
443 n1.version = 1;
444 n1.put("key1", "value1");
445 Date timestamp = new Date();
446 n1.setTimestamp(timestamp);
447 their.addPrimitive(n1);
448
449
450 MergeVisitor visitor = new MergeVisitor(my,their);
451 visitor.merge();
452
453 Node n2 = my.nodes.iterator().next();
454 assertEquals(0,visitor.getConflicts().size());
455 assertEquals("value1",n2.get("key1"));
456 assertEquals(true, n1.getTimestamp().equals(n2.getTimestamp()));
457 assertEquals(false, n2.incomplete);
458 }
459
460 /**
461 * their way has a higher version and different tags. the nodes are the same. My
462 * way is not modified. Merge is possible. No conflict.
463 *
464 * => merge it onto my way.
465 *
466 */
467 @Test
468 public void waySimple_IdenicalNodesDifferentTags() {
469
470
471 DataSet my = new DataSet();
472 my.version = "0.6";
473
474 Node n1 = new Node(new LatLon(0,0));
475 n1.id = 1;
476 n1.version = 1;
477 my.addPrimitive(n1);
478
479 Node n2 = new Node(new LatLon(1,1));
480 n2.id = 2;
481 n2.version = 1;
482 my.addPrimitive(n2);
483
484 Way myWay = new Way();
485 myWay.id = 3;
486 myWay.version = 1;
487 myWay.put("key1", "value1");
488 myWay.nodes.add(n1);
489 myWay.nodes.add(n2);
490 my.addPrimitive(myWay);
491
492 DataSet their = new DataSet();
493 their.version = "0.6";
494
495 Node n3 = new Node(new LatLon(0,0));
496 n3.id = 1;
497 n3.version = 1;
498 their.addPrimitive(n3);
499
500 Node n4 = new Node(new LatLon(1,1));
501 n4.id = 2;
502 n4.version = 1;
503 their.addPrimitive(n4);
504
505 Way theirWay = new Way();
506 theirWay.id = 3;
507 theirWay.version = 2;
508 theirWay.put("key1", "value1");
509 theirWay.put("key2", "value2");
510 theirWay.nodes.add(n3);
511 theirWay.nodes.add(n4);
512 their.addPrimitive(theirWay);
513
514
515 MergeVisitor visitor = new MergeVisitor(my,their);
516 visitor.merge();
517
518 Way merged = (Way)my.getPrimitiveById(3);
519 assertEquals(0,visitor.getConflicts().size());
520 assertEquals("value1",merged.get("key1"));
521 assertEquals("value2",merged.get("key2"));
522 assertEquals(3,merged.id);
523 assertEquals(2,merged.version);
524 assertEquals(2,merged.nodes.size());
525 assertEquals(1,merged.nodes.get(0).id);
526 assertEquals(2,merged.nodes.get(1).id);
527
528 }
529
530 /**
531 * their way has a higher version and different tags. And it has more nodes. Two
532 * of the existing nodes are modified.
533 *
534 * => merge it onto my way, no conflict
535 *
536 */
537 @Test
538 public void waySimple_AdditionalNodesAndChangedNodes() {
539
540 DataSet my = new DataSet();
541 my.version = "0.6";
542
543 Node n1 = new Node(new LatLon(0,0));
544 n1.id = 1;
545 n1.version = 1;
546 my.addPrimitive(n1);
547
548 Node n2 = new Node(new LatLon(1,1));
549 n2.id = 2;
550 n2.version = 1;
551 my.addPrimitive(n2);
552
553 Way myWay = new Way();
554 myWay.id = 3;
555 myWay.version = 1;
556 myWay.nodes.add(n1);
557 myWay.nodes.add(n2);
558 my.addPrimitive(myWay);
559
560 DataSet their = new DataSet();
561 their.version = "0.6";
562
563 Node n3 = new Node(new LatLon(0,0));
564 n3.id = 1;
565 n3.version = 1;
566 their.addPrimitive(n3);
567
568 Node n5 = new Node(new LatLon(1,1));
569 n5.id = 4;
570 n5.version = 1;
571 their.addPrimitive(n5);
572
573 their.addPrimitive(n5);
574
575 Node n4 = new Node(new LatLon(2,2));
576 n4.id = 2;
577 n4.version = 2;
578 n4.put("key1", "value1");
579 their.addPrimitive(n4);
580
581
582 Way theirWay = new Way();
583 theirWay.id = 3;
584 theirWay.version = 2;
585 theirWay.nodes.add(n3);
586 theirWay.nodes.add(n5); // insert a node
587 theirWay.nodes.add(n4); // this one is updated
588 their.addPrimitive(theirWay);
589
590
591 MergeVisitor visitor = new MergeVisitor(my,their);
592 visitor.merge();
593
594 Way merged = (Way)my.getPrimitiveById(3);
595 assertEquals(0,visitor.getConflicts().size());
596 assertEquals(3,merged.id);
597 assertEquals(2,merged.version);
598 assertEquals(3,merged.nodes.size());
599 assertEquals(1,merged.nodes.get(0).id);
600 assertEquals(4,merged.nodes.get(1).id);
601 assertEquals(2,merged.nodes.get(2).id);
602 assertEquals("value1",merged.nodes.get(2).get("key1"));
603 }
604
605 /**
606 * their way has a higher version and different nodes. My way is modified.
607 *
608 * => merge it onto my way not possbile, conflict
609 *
610 */
611 @Test
612 public void waySimple_DifferentNodesAndMyIsModified() {
613
614 DataSet my = new DataSet();
615 my.version = "0.6";
616
617 Node n1 = new Node(new LatLon(0,0));
618 n1.id = 1;
619 n1.version = 1;
620 my.addPrimitive(n1);
621
622 Node n2 = new Node(new LatLon(1,1));
623 n2.id = 2;
624 n2.version = 1;
625 my.addPrimitive(n2);
626
627 Way myWay = new Way();
628 myWay.id = 3;
629 myWay.version = 1;
630 myWay.nodes.add(n1);
631 myWay.nodes.add(n2);
632 myWay.modified = true;
633 myWay.put("key1", "value1");
634 my.addPrimitive(myWay);
635
636 DataSet their = new DataSet();
637 their.version = "0.6";
638
639 Node n3 = new Node(new LatLon(0,0));
640 n3.id = 1;
641 n3.version = 1;
642 their.addPrimitive(n3);
643
644 Node n5 = new Node(new LatLon(1,1));
645 n5.id = 4;
646 n5.version = 1;
647 their.addPrimitive(n5);
648
649 their.addPrimitive(n5);
650
651 Node n4 = new Node(new LatLon(2,2));
652 n4.id = 2;
653 n4.version = 2;
654 n4.put("key1", "value1");
655 their.addPrimitive(n4);
656
657
658 Way theirWay = new Way();
659 theirWay.id = 3;
660 theirWay.version = 2;
661 theirWay.nodes.add(n3);
662 theirWay.nodes.add(n5); // insert a node
663 theirWay.nodes.add(n4); // this one is updated
664 their.addPrimitive(theirWay);
665
666
667 MergeVisitor visitor = new MergeVisitor(my,their);
668 visitor.merge();
669
670 Way merged = (Way)my.getPrimitiveById(3);
671 assertEquals(1,visitor.getConflicts().size());
672 assertEquals(3,merged.id);
673 assertEquals(1,merged.version);
674 assertEquals(2,merged.nodes.size());
675 assertEquals(1,merged.nodes.get(0).id);
676 assertEquals(2,merged.nodes.get(1).id);
677 assertEquals("value1",merged.get("key1"));
678 }
679
680
681 /**
682 * their way is not visible anymore.
683 *
684 * => conflict
685 *
686 */
687 @Test
688 public void waySimple_TheirVersionNotVisible() {
689
690 DataSet my = new DataSet();
691 my.version = "0.6";
692
693 Node n1 = new Node(new LatLon(0,0));
694 n1.id = 1;
695 n1.version = 1;
696 my.addPrimitive(n1);
697
698 Node n2 = new Node(new LatLon(1,1));
699 n2.id = 2;
700 n2.version = 1;
701 my.addPrimitive(n2);
702
703 Way myWay = new Way();
704 myWay.id = 3;
705 myWay.version = 1;
706 myWay.nodes.add(n1);
707 myWay.nodes.add(n2);
708 my.addPrimitive(myWay);
709
710 DataSet their = new DataSet();
711 their.version = "0.6";
712
713 Way theirWay = new Way();
714 theirWay.id = 3;
715 theirWay.version = 2;
716 theirWay.visible = false;
717 their.addPrimitive(theirWay);
718
719 MergeVisitor visitor = new MergeVisitor(my,their);
720 visitor.merge();
721
722 Way merged = (Way)my.getPrimitiveById(3);
723 assertEquals(1,visitor.getConflicts().size());
724 assertEquals(true, visitor.getConflicts().hasConflictForMy(myWay));
725 assertEquals(true, visitor.getConflicts().hasConflictForTheir(theirWay));
726 assertEquals(myWay,merged);
727 }
728
729 /**
730 * my and their way have no ids, nodes they refer to have an id. but
731 * my and their way are semantically equal. so technical attributes of
732 * their way can be merged on my way. No conflict.
733 *
734 *
735 *
736 */
737 @Test
738 public void waySimple_twoWaysWithNoId_NodesWithId() {
739
740 DataSet my = new DataSet();
741 my.version = "0.6";
742
743 Node n1 = new Node(new LatLon(0,0));
744 n1.id = 1;
745 n1.version = 1;
746 my.addPrimitive(n1);
747
748 Node n2 = new Node(new LatLon(1,1));
749 n2.id = 2;
750 n2.version = 1;
751 my.addPrimitive(n2);
752
753 Way myWay = new Way();
754 myWay.id = 0;
755 myWay.version = -1;
756 myWay.nodes.add(n1);
757 myWay.nodes.add(n2);
758 my.addPrimitive(myWay);
759
760 DataSet their = new DataSet();
761 their.version = "0.6";
762
763 Node n3 = new Node(new LatLon(0,0));
764 n3.id = 1;
765 n3.version = 1;
766 their.addPrimitive(n3);
767
768 Node n4 = new Node(new LatLon(1,1));
769 n4.id = 2;
770 n4.version = 1;
771 their.addPrimitive(n4);
772
773 Way theirWay = new Way();
774 theirWay.id = 0;
775 theirWay.version = -1;
776 theirWay.nodes.add(n3);
777 theirWay.nodes.add(n4);
778 theirWay.user = User.get("their");
779 theirWay.user.uid = "1111";
780 theirWay.setTimestamp(new Date());
781 their.addPrimitive(theirWay);
782
783 MergeVisitor visitor = new MergeVisitor(my,their);
784 visitor.merge();
785
786 assertEquals(0,visitor.getConflicts().size());
787 assertEquals("their", myWay.user.name);
788 assertEquals("1111", myWay.user.uid);
789 assertEquals("1111", myWay.user.uid);
790 assertEquals(theirWay.getTimestamp(), myWay.getTimestamp());
791 }
792
793 /**
794 * my and their way have no ids, neither do the nodes they refer to. but
795 * my and their way are semantically equal. so technical attributes of
796 * their way can be merged on my way. No conflict.
797 *
798 */
799 @Test
800 public void waySimple_twoWaysWithNoId_NodesWithoutId() {
801
802 DataSet my = new DataSet();
803 my.version = "0.6";
804
805 Node n1 = new Node(new LatLon(0,0));
806 n1.id = 0;
807 n1.version = -1;
808 my.addPrimitive(n1);
809
810 Node n2 = new Node(new LatLon(1,1));
811 n2.id = 0;
812 n2.version = -1;
813 my.addPrimitive(n2);
814
815 Way myWay = new Way();
816 myWay.id = 0;
817 myWay.version = -1;
818 myWay.nodes.add(n1);
819 myWay.nodes.add(n2);
820 my.addPrimitive(myWay);
821
822 DataSet their = new DataSet();
823 their.version = "0.6";
824
825 Node n3 = new Node(new LatLon(0,0));
826 n3.id = 0;
827 n3.version = -1;
828 their.addPrimitive(n3);
829
830 Node n4 = new Node(new LatLon(1,1));
831 n4.id = 0;
832 n4.version = -1;
833 their.addPrimitive(n4);
834
835 Way theirWay = new Way();
836 theirWay.id = 0;
837 theirWay.version = -1;
838 theirWay.nodes.add(n3);
839 theirWay.nodes.add(n4);
840 theirWay.user = User.get("their");
841 theirWay.user.uid = "1111";
842 theirWay.setTimestamp(new Date());
843 their.addPrimitive(theirWay);
844
845 MergeVisitor visitor = new MergeVisitor(my,their);
846 visitor.merge();
847
848 assertEquals(0,visitor.getConflicts().size());
849 assertEquals("their", myWay.user.name);
850 assertEquals("1111", myWay.user.uid);
851 assertEquals("1111", myWay.user.uid);
852 assertEquals(theirWay.getTimestamp(), myWay.getTimestamp());
853 }
854}
Note: See TracBrowser for help on using the repository browser.