?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[492341] Res Att Change correctly implies diffs
[EMFCompare2.git] / plugins / org.eclipse.emf.compare.tests / src / org / eclipse / emf / compare / tests / req / ReqComputingTest.java
bloba316870b0e4866739eabbce4ef56fdc144d98350
1 /*******************************************************************************
2 * Copyright (c) 2012, 2014 Obeo.
3 * All rights reserved. This program and the accompanying materials
4 * are made available under the terms of the Eclipse Public License v1.0
5 * which accompanies this distribution, and is available at
6 * http://www.eclipse.org/legal/epl-v10.html
7 *
8 * Contributors:
9 * Obeo - initial API and implementation
10 *******************************************************************************/
11 package org.eclipse.emf.compare.tests.req;
12
13 import static com.google.common.collect.Iterables.filter;
14 import static com.google.common.collect.Iterables.getOnlyElement;
15 import static org.eclipse.emf.compare.utils.EMFComparePredicates.added;
16 import static org.eclipse.emf.compare.utils.EMFComparePredicates.addedToReference;
17 import static org.eclipse.emf.compare.utils.EMFComparePredicates.changedReference;
18 import static org.eclipse.emf.compare.utils.EMFComparePredicates.movedInReference;
19 import static org.eclipse.emf.compare.utils.EMFComparePredicates.removed;
20 import static org.eclipse.emf.compare.utils.EMFComparePredicates.removedFromReference;
21 import static org.junit.Assert.assertEquals;
22 import static org.junit.Assert.assertNotNull;
23 import static org.junit.Assert.assertTrue;
24
25 import com.google.common.base.Predicate;
26 import com.google.common.base.Predicates;
27 import com.google.common.collect.Collections2;
28 import com.google.common.collect.Iterators;
29
30 import java.io.IOException;
31 import java.util.Collection;
32 import java.util.List;
33
34 import org.eclipse.emf.common.util.EList;
35 import org.eclipse.emf.compare.Comparison;
36 import org.eclipse.emf.compare.Diff;
37 import org.eclipse.emf.compare.EMFCompare;
38 import org.eclipse.emf.compare.ReferenceChange;
39 import org.eclipse.emf.compare.ResourceAttachmentChange;
40 import org.eclipse.emf.compare.scope.DefaultComparisonScope;
41 import org.eclipse.emf.compare.scope.IComparisonScope;
42 import org.eclipse.emf.compare.tests.req.data.ReqInputData;
43 import org.eclipse.emf.ecore.resource.Resource;
44 import org.eclipse.emf.ecore.resource.ResourceSet;
45 import org.eclipse.emf.ecore.util.EcoreUtil;
46 import org.junit.Test;
47
48 @SuppressWarnings("nls")
49 public class ReqComputingTest {
50
51 enum TestKind {
52 ADD, DELETE;
53 }
54
55 private ReqInputData input = new ReqInputData();
56
57 @Test
58 public void testA1UseCase() throws IOException {
59 final Resource left = input.getA1Left();
60 final Resource right = input.getA1Right();
61
62 final IComparisonScope scope = new DefaultComparisonScope(left, right, null);
63 final Comparison comparison = EMFCompare.builder().build().compare(scope);
64 testAB1(TestKind.DELETE, comparison);
65 }
66
67 @Test
68 public void testA2UseCase() throws IOException {
69 final Resource left = input.getA2Left();
70 final Resource right = input.getA2Right();
71
72 final IComparisonScope scope = new DefaultComparisonScope(left, right, null);
73 final Comparison comparison = EMFCompare.builder().build().compare(scope);
74 testAB2(TestKind.DELETE, comparison);
75 }
76
77 @Test
78 public void testA3UseCase() throws IOException {
79 final Resource left = input.getA3Left();
80 final Resource right = input.getA3Right();
81
82 final IComparisonScope scope = new DefaultComparisonScope(left, right, null);
83 final Comparison comparison = EMFCompare.builder().build().compare(scope);
84 testAB3(TestKind.DELETE, comparison);
85 }
86
87 @Test
88 public void testA4UseCase() throws IOException {
89 final Resource left = input.getA4Left();
90 final Resource right = input.getA4Right();
91
92 final IComparisonScope scope = new DefaultComparisonScope(left, right, null);
93 final Comparison comparison = EMFCompare.builder().build().compare(scope);
94 testAB4(TestKind.DELETE, comparison);
95 }
96
97 @Test
98 public void testA5UseCase() throws IOException {
99 final Resource left = input.getA5Left();
100 final Resource right = input.getA5Right();
101
102 final IComparisonScope scope = new DefaultComparisonScope(left, right, null);
103 final Comparison comparison = EMFCompare.builder().build().compare(scope);
104 testAB5(TestKind.DELETE, comparison);
105 }
106
107 @Test
108 public void testA6UseCase() throws IOException {
109 final Resource left = input.getA6Left();
110 final Resource right = input.getA6Right();
111
112 final IComparisonScope scope = new DefaultComparisonScope(left, right, null);
113 final Comparison comparison = EMFCompare.builder().build().compare(scope);
114 testAB6(TestKind.DELETE, comparison);
115
116 }
117
118 @Test
119 public void testA7UseCase() throws IOException {
120 final Resource left = input.getA7Left();
121 final Resource right = input.getA7Right();
122
123 final IComparisonScope scope = new DefaultComparisonScope(left, right, null);
124 final Comparison comparison = EMFCompare.builder().build().compare(scope);
125 testAB7(TestKind.ADD, comparison);
126 }
127
128 @Test
129 public void testA8UseCase() throws IOException {
130 final Resource left = input.getA8Left();
131 final Resource right = input.getA8Right();
132
133 final IComparisonScope scope = new DefaultComparisonScope(left, right, null);
134 final Comparison comparison = EMFCompare.builder().build().compare(scope);
135 testAB8(TestKind.ADD, comparison);
136 }
137
138 @Test
139 public void testA9UseCase() throws IOException {
140 final Resource left = input.getA9Left();
141 final Resource right = input.getA9Right();
142
143 final IComparisonScope scope = new DefaultComparisonScope(left, right, null);
144 final Comparison comparison = EMFCompare.builder().build().compare(scope);
145 testAB9(TestKind.ADD, comparison);
146 }
147
148 @Test
149 public void testA10UseCase() throws IOException {
150 final Resource left = input.getA10Left();
151 final Resource right = input.getA10Right();
152
153 final IComparisonScope scope = new DefaultComparisonScope(left, right, null);
154 final Comparison comparison = EMFCompare.builder().build().compare(scope);
155 testAB10(TestKind.ADD, comparison);
156 }
157
158 @Test
159 public void testA11UseCase() throws IOException {
160 final Resource left = input.getA11Left();
161 final Resource right = input.getA11Right();
162
163 final IComparisonScope scope = new DefaultComparisonScope(left, right, null);
164 final Comparison comparison = EMFCompare.builder().build().compare(scope);
165 testAB11(TestKind.ADD, comparison);
166 }
167
168 @Test
169 public void testB1UseCase() throws IOException {
170 final Resource left = input.getA1Left();
171 final Resource right = input.getA1Right();
172
173 final IComparisonScope scope = new DefaultComparisonScope(right, left, null);
174 final Comparison comparison = EMFCompare.builder().build().compare(scope);
175 testAB1(TestKind.ADD, comparison);
176 }
177
178 @Test
179 public void testB2UseCase() throws IOException {
180 final Resource left = input.getA2Left();
181 final Resource right = input.getA2Right();
182
183 final IComparisonScope scope = new DefaultComparisonScope(right, left, null);
184 final Comparison comparison = EMFCompare.builder().build().compare(scope);
185 testAB2(TestKind.ADD, comparison);
186 }
187
188 @Test
189 public void testB3UseCase() throws IOException {
190 final Resource left = input.getA3Left();
191 final Resource right = input.getA3Right();
192
193 final IComparisonScope scope = new DefaultComparisonScope(right, left, null);
194 final Comparison comparison = EMFCompare.builder().build().compare(scope);
195 testAB3(TestKind.ADD, comparison);
196 }
197
198 @Test
199 public void testB4UseCase() throws IOException {
200 final Resource left = input.getA4Left();
201 final Resource right = input.getA4Right();
202
203 final IComparisonScope scope = new DefaultComparisonScope(right, left, null);
204 final Comparison comparison = EMFCompare.builder().build().compare(scope);
205 testAB4(TestKind.ADD, comparison);
206 }
207
208 @Test
209 public void testB5UseCase() throws IOException {
210 final Resource left = input.getA5Left();
211 final Resource right = input.getA5Right();
212
213 final IComparisonScope scope = new DefaultComparisonScope(right, left, null);
214 final Comparison comparison = EMFCompare.builder().build().compare(scope);
215 testAB5(TestKind.ADD, comparison);
216 }
217
218 @Test
219 public void testB6UseCase() throws IOException {
220 final Resource left = input.getA6Left();
221 final Resource right = input.getA6Right();
222
223 final IComparisonScope scope = new DefaultComparisonScope(right, left, null);
224 final Comparison comparison = EMFCompare.builder().build().compare(scope);
225 testAB6(TestKind.ADD, comparison);
226 }
227
228 @Test
229 public void testB7UseCase() throws IOException {
230 final Resource left = input.getA7Left();
231 final Resource right = input.getA7Right();
232
233 final IComparisonScope scope = new DefaultComparisonScope(right, left, null);
234 final Comparison comparison = EMFCompare.builder().build().compare(scope);
235 testAB7(TestKind.DELETE, comparison);
236 }
237
238 @Test
239 public void testB8UseCase() throws IOException {
240 final Resource left = input.getA8Left();
241 final Resource right = input.getA8Right();
242
243 final IComparisonScope scope = new DefaultComparisonScope(right, left, null);
244 final Comparison comparison = EMFCompare.builder().build().compare(scope);
245 testAB8(TestKind.DELETE, comparison);
246 }
247
248 @Test
249 public void testB9UseCase() throws IOException {
250 final Resource left = input.getA9Left();
251 final Resource right = input.getA9Right();
252
253 final IComparisonScope scope = new DefaultComparisonScope(right, left, null);
254 final Comparison comparison = EMFCompare.builder().build().compare(scope);
255 testAB9(TestKind.DELETE, comparison);
256 }
257
258 @Test
259 public void testB10UseCase() throws IOException {
260 final Resource left = input.getA10Left();
261 final Resource right = input.getA10Right();
262
263 final IComparisonScope scope = new DefaultComparisonScope(right, left, null);
264 final Comparison comparison = EMFCompare.builder().build().compare(scope);
265 testAB10(TestKind.DELETE, comparison);
266 }
267
268 @Test
269 public void testB11UseCase() throws IOException {
270 final Resource left = input.getA11Left();
271 final Resource right = input.getA11Right();
272
273 final IComparisonScope scope = new DefaultComparisonScope(right, left, null);
274 final Comparison comparison = EMFCompare.builder().build().compare(scope);
275 testAB11(TestKind.DELETE, comparison);
276 }
277
278 @Test
279 public void testC1UseCase() throws IOException {
280 final Resource left = input.getC1Left();
281 final Resource right = input.getC1Right();
282
283 final IComparisonScope scope = new DefaultComparisonScope(left, right, null);
284 final Comparison comparison = EMFCompare.builder().build().compare(scope);
285 testCD1(TestKind.DELETE, comparison);
286 }
287
288 @Test
289 public void testC2UseCase() throws IOException {
290 final Resource left = input.getC2Left();
291 final Resource right = input.getC2Right();
292
293 final IComparisonScope scope = new DefaultComparisonScope(left, right, null);
294 final Comparison comparison = EMFCompare.builder().build().compare(scope);
295 testCD2(TestKind.DELETE, comparison);
296 }
297
298 @Test
299 public void testC3UseCase() throws IOException {
300 final Resource left = input.getC3Left();
301 final Resource right = input.getC3Right();
302
303 final IComparisonScope scope = new DefaultComparisonScope(left, right, null);
304 final Comparison comparison = EMFCompare.builder().build().compare(scope);
305 testCD3(TestKind.DELETE, comparison);
306 }
307
308 @Test
309 public void testC4UseCase() throws IOException {
310 final Resource left = input.getC4Left();
311 final Resource right = input.getC4Right();
312
313 final IComparisonScope scope = new DefaultComparisonScope(left, right, null);
314 final Comparison comparison = EMFCompare.builder().build().compare(scope);
315 testCD4(TestKind.DELETE, comparison);
316 }
317
318 @Test
319 public void testC5UseCase() throws IOException {
320 final Resource left = input.getC5Left();
321 final Resource right = input.getC5Right();
322
323 final IComparisonScope scope = new DefaultComparisonScope(left, right, null);
324 final Comparison comparison = EMFCompare.builder().build().compare(scope);
325 testCD5(TestKind.DELETE, comparison);
326 }
327
328 @Test
329 public void testD1UseCase() throws IOException {
330 final Resource left = input.getC1Left();
331 final Resource right = input.getC1Right();
332
333 final IComparisonScope scope = new DefaultComparisonScope(right, left, null);
334 final Comparison comparison = EMFCompare.builder().build().compare(scope);
335 testCD1(TestKind.ADD, comparison);
336 }
337
338 @Test
339 public void testD2UseCase() throws IOException {
340 final Resource left = input.getC2Left();
341 final Resource right = input.getC2Right();
342
343 final IComparisonScope scope = new DefaultComparisonScope(right, left, null);
344 final Comparison comparison = EMFCompare.builder().build().compare(scope);
345 testCD2(TestKind.ADD, comparison);
346 }
347
348 @Test
349 public void testD3UseCase() throws IOException {
350 final Resource left = input.getC3Left();
351 final Resource right = input.getC3Right();
352
353 final IComparisonScope scope = new DefaultComparisonScope(right, left, null);
354 final Comparison comparison = EMFCompare.builder().build().compare(scope);
355 testCD3(TestKind.ADD, comparison);
356 }
357
358 @Test
359 public void testD4UseCase() throws IOException {
360 final Resource left = input.getC4Left();
361 final Resource right = input.getC4Right();
362
363 final IComparisonScope scope = new DefaultComparisonScope(right, left, null);
364 final Comparison comparison = EMFCompare.builder().build().compare(scope);
365 testCD4(TestKind.ADD, comparison);
366 }
367
368 @Test
369 public void testD5UseCase() throws IOException {
370 final Resource left = input.getC5Left();
371 final Resource right = input.getC5Right();
372
373 final IComparisonScope scope = new DefaultComparisonScope(right, left, null);
374 final Comparison comparison = EMFCompare.builder().build().compare(scope);
375 testCD5(TestKind.ADD, comparison);
376 }
377
378 @Test
379 public void testE1UseCase1() throws IOException {
380 final Resource left = input.getE1Left();
381 final Resource right = input.getE1Right();
382 final Resource ancestor = input.getE1Ancestor();
383
384 final IComparisonScope scope = new DefaultComparisonScope(left, right, ancestor);
385 final Comparison comparison = EMFCompare.builder().build().compare(scope);
386 testAB1(TestKind.DELETE, comparison);
387 }
388
389 @Test
390 public void testE2UseCase() throws IOException {
391 final Resource left = input.getE2Left();
392 final Resource right = input.getE2Right();
393 final Resource ancestor = input.getE2Ancestor();
394
395 final IComparisonScope scope = new DefaultComparisonScope(left, right, ancestor);
396 final Comparison comparison = EMFCompare.builder().build().compare(scope);
397 testAB2(TestKind.DELETE, comparison);
398 }
399
400 @Test
401 public void testE3UseCase() throws IOException {
402 final Resource left = input.getE3Left();
403 final Resource right = input.getE3Right();
404 final Resource ancestor = input.getE3Ancestor();
405
406 final IComparisonScope scope = new DefaultComparisonScope(left, right, ancestor);
407 final Comparison comparison = EMFCompare.builder().build().compare(scope);
408 testAB3(TestKind.DELETE, comparison);
409 }
410
411 @Test
412 public void testE4UseCase() throws IOException {
413 final Resource left = input.getE4Left();
414 final Resource right = input.getE4Right();
415 final Resource ancestor = input.getE4Ancestor();
416
417 final IComparisonScope scope = new DefaultComparisonScope(left, right, ancestor);
418 final Comparison comparison = EMFCompare.builder().build().compare(scope);
419 testAB4(TestKind.DELETE, comparison);
420 }
421
422 @Test
423 public void testE5UseCase() throws IOException {
424 final Resource left = input.getE5Left();
425 final Resource right = input.getE5Right();
426 final Resource ancestor = input.getE5Ancestor();
427
428 final IComparisonScope scope = new DefaultComparisonScope(left, right, ancestor);
429 final Comparison comparison = EMFCompare.builder().build().compare(scope);
430 testAB5(TestKind.DELETE, comparison);
431 }
432
433 @Test
434 public void testE6UseCase() throws IOException {
435 final Resource left = input.getE6Left();
436 final Resource right = input.getE6Right();
437 final Resource ancestor = input.getE6Ancestor();
438
439 final IComparisonScope scope = new DefaultComparisonScope(left, right, ancestor);
440 final Comparison comparison = EMFCompare.builder().build().compare(scope);
441 testAB6(TestKind.DELETE, comparison);
442 }
443
444 @Test
445 public void testE7UseCase() throws IOException {
446 final Resource left = input.getE7Left();
447 final Resource right = input.getE7Right();
448 final Resource ancestor = input.getE7Ancestor();
449
450 final IComparisonScope scope = new DefaultComparisonScope(left, right, ancestor);
451 final Comparison comparison = EMFCompare.builder().build().compare(scope);
452 testCD1(TestKind.DELETE, comparison);
453 }
454
455 @Test
456 public void testE8UseCase() throws IOException {
457 final Resource left = input.getE8Left();
458 final Resource right = input.getE8Right();
459 final Resource ancestor = input.getE8Ancestor();
460
461 final IComparisonScope scope = new DefaultComparisonScope(left, right, ancestor);
462 final Comparison comparison = EMFCompare.builder().build().compare(scope);
463 testCD2(TestKind.DELETE, comparison);
464 }
465
466 @Test
467 public void testE9UseCase() throws IOException {
468 final Resource left = input.getE9Left();
469 final Resource right = input.getE9Right();
470 final Resource ancestor = input.getE9Ancestor();
471
472 final IComparisonScope scope = new DefaultComparisonScope(left, right, ancestor);
473 final Comparison comparison = EMFCompare.builder().build().compare(scope);
474 testCD3(TestKind.DELETE, comparison);
475 }
476
477 @Test
478 public void testE10UseCase() throws IOException {
479 final Resource left = input.getE10Left();
480 final Resource right = input.getE10Right();
481 final Resource ancestor = input.getE10Ancestor();
482
483 final IComparisonScope scope = new DefaultComparisonScope(left, right, ancestor);
484 final Comparison comparison = EMFCompare.builder().build().compare(scope);
485 testCD4(TestKind.DELETE, comparison);
486 }
487
488 @Test
489 public void testE11UseCase() throws IOException {
490 final Resource left = input.getE11Left();
491 final Resource right = input.getE11Right();
492 final Resource ancestor = input.getE11Ancestor();
493
494 final IComparisonScope scope = new DefaultComparisonScope(left, right, ancestor);
495 final Comparison comparison = EMFCompare.builder().build().compare(scope);
496 testCD5(TestKind.DELETE, comparison);
497 }
498
499 @Test
500 public void testF1UseCase1() throws IOException {
501 final Resource left = input.getF1Left();
502 final Resource right = input.getF1Right();
503 final Resource ancestor = input.getF1Ancestor();
504
505 final IComparisonScope scope = new DefaultComparisonScope(left, right, ancestor);
506 final Comparison comparison = EMFCompare.builder().build().compare(scope);
507 testAB1(TestKind.ADD, comparison);
508 }
509
510 @Test
511 public void testF2UseCase() throws IOException {
512 final Resource left = input.getF2Left();
513 final Resource right = input.getF2Right();
514 final Resource ancestor = input.getF2Ancestor();
515
516 final IComparisonScope scope = new DefaultComparisonScope(left, right, ancestor);
517 final Comparison comparison = EMFCompare.builder().build().compare(scope);
518 testAB2(TestKind.ADD, comparison);
519 }
520
521 @Test
522 public void testF3UseCase() throws IOException {
523 final Resource left = input.getF3Left();
524 final Resource right = input.getF3Right();
525 final Resource ancestor = input.getF3Ancestor();
526
527 final IComparisonScope scope = new DefaultComparisonScope(left, right, ancestor);
528 final Comparison comparison = EMFCompare.builder().build().compare(scope);
529 testAB3(TestKind.ADD, comparison);
530 }
531
532 @Test
533 public void testF4UseCase() throws IOException {
534 final Resource left = input.getF4Left();
535 final Resource right = input.getF4Right();
536 final Resource ancestor = input.getF4Ancestor();
537
538 final IComparisonScope scope = new DefaultComparisonScope(left, right, ancestor);
539 final Comparison comparison = EMFCompare.builder().build().compare(scope);
540 testAB4(TestKind.ADD, comparison);
541 }
542
543 @Test
544 public void testF5UseCase() throws IOException {
545 final Resource left = input.getF5Left();
546 final Resource right = input.getF5Right();
547 final Resource ancestor = input.getF5Ancestor();
548
549 final IComparisonScope scope = new DefaultComparisonScope(left, right, ancestor);
550 final Comparison comparison = EMFCompare.builder().build().compare(scope);
551 testAB5(TestKind.ADD, comparison);
552 }
553
554 @Test
555 public void testF6UseCase() throws IOException {
556 final Resource left = input.getF6Left();
557 final Resource right = input.getF6Right();
558 final Resource ancestor = input.getF6Ancestor();
559
560 final IComparisonScope scope = new DefaultComparisonScope(left, right, ancestor);
561 final Comparison comparison = EMFCompare.builder().build().compare(scope);
562 testAB6(TestKind.ADD, comparison);
563 }
564
565 @Test
566 public void testF7UseCase() throws IOException {
567 final Resource left = input.getF7Left();
568 final Resource right = input.getF7Right();
569 final Resource ancestor = input.getF7Ancestor();
570
571 final IComparisonScope scope = new DefaultComparisonScope(left, right, ancestor);
572 final Comparison comparison = EMFCompare.builder().build().compare(scope);
573 testCD1(TestKind.ADD, comparison);
574 }
575
576 @Test
577 public void testF8UseCase() throws IOException {
578 final Resource left = input.getF8Left();
579 final Resource right = input.getF8Right();
580 final Resource ancestor = input.getF8Ancestor();
581
582 final IComparisonScope scope = new DefaultComparisonScope(left, right, ancestor);
583 final Comparison comparison = EMFCompare.builder().build().compare(scope);
584 testCD2(TestKind.ADD, comparison);
585 }
586
587 @Test
588 public void testF9UseCase() throws IOException {
589 final Resource left = input.getF9Left();
590 final Resource right = input.getF9Right();
591 final Resource ancestor = input.getF9Ancestor();
592
593 final IComparisonScope scope = new DefaultComparisonScope(left, right, ancestor);
594 final Comparison comparison = EMFCompare.builder().build().compare(scope);
595 testCD3(TestKind.ADD, comparison);
596 }
597
598 @Test
599 public void testF10UseCase() throws IOException {
600 final Resource left = input.getF10Left();
601 final Resource right = input.getF10Right();
602 final Resource ancestor = input.getF10Ancestor();
603
604 final IComparisonScope scope = new DefaultComparisonScope(left, right, ancestor);
605 final Comparison comparison = EMFCompare.builder().build().compare(scope);
606 testCD4(TestKind.ADD, comparison);
607 }
608
609 @Test
610 public void testF11UseCase() throws IOException {
611 final Resource left = input.getF11Left();
612 final Resource right = input.getF11Right();
613 final Resource ancestor = input.getF11Ancestor();
614
615 final IComparisonScope scope = new DefaultComparisonScope(left, right, ancestor);
616 final Comparison comparison = EMFCompare.builder().build().compare(scope);
617 testCD5(TestKind.ADD, comparison);
618 }
619
620 @Test
621 public void testG1UseCase() throws IOException {
622 final Resource left = input.getG1Left();
623 final Resource right = input.getG1Right();
624
625 final IComparisonScope scope = new DefaultComparisonScope(left, right, null);
626 final Comparison comparison = EMFCompare.builder().build().compare(scope);
627 String root = "root";
628 String node1 = root + ".node1";
629 String node2 = node1 + ".node2";
630
631 EList<Diff> differences = comparison.getDifferences();
632
633 assertEquals(3, differences.size());
634 Diff added1 = getOnlyElement(filter(differences, added(node1)), null);
635 assertNotNull(added1);
636 Diff added2 = getOnlyElement(filter(differences, added(node2)), null);
637 assertNotNull(added2);
638
639 ReferenceChange singleChange = null;
640 for (ReferenceChange change : filter(differences, ReferenceChange.class)) {
641 if ("singleValuedReference".equals(change.getReference().getName())) {
642 singleChange = change;
643 break;
644 }
645 }
646 assertNotNull(singleChange);
647 // Happy compiler
648 assert singleChange != null;
649 assertTrue(singleChange.getValue().eIsProxy());
650 assertEquals(0, added1.getRequires().size());
651 assertEquals(1, added2.getRequires().size());
652 assertTrue(added2.getRequires().contains(added1));
653 assertEquals(1, singleChange.getRequires().size());
654 assertTrue(singleChange.getRequires().contains(added2));
655 }
656
657 @Test
658 public void testH1UseCase() throws IOException {
659 final Resource left = input.getH1Left();
660 final Resource origin = input.getH1Ancestor();
661 final Resource right = input.getH1Right();
662
663 final ResourceSet leftSet = left.getResourceSet();
664 final ResourceSet originSet = origin.getResourceSet();
665 final ResourceSet rightSet = right.getResourceSet();
666
667 assertNotNull(leftSet);
668 assertNotNull(originSet);
669 assertNotNull(rightSet);
670
671 EcoreUtil.resolveAll(leftSet);
672 EcoreUtil.resolveAll(originSet);
673 EcoreUtil.resolveAll(rightSet);
674
675 assertEquals(1, leftSet.getResources().size());
676 assertEquals(2, originSet.getResources().size());
677 assertEquals(2, rightSet.getResources().size());
678
679 IComparisonScope scope = new DefaultComparisonScope(leftSet, rightSet, originSet);
680 Comparison comparison = EMFCompare.builder().build().compare(scope);
681 testH(TestKind.DELETE, comparison);
682
683 scope = new DefaultComparisonScope(rightSet, leftSet, originSet);
684 comparison = EMFCompare.builder().build().compare(scope);
685 testH(TestKind.DELETE, comparison);
686 }
687
688 @Test
689 public void testH2UseCase() throws IOException {
690 final Resource left = input.getH2Left();
691 final Resource origin = input.getH2Ancestor();
692 final Resource right = input.getH2Right();
693
694 final ResourceSet leftSet = left.getResourceSet();
695 final ResourceSet originSet = origin.getResourceSet();
696 final ResourceSet rightSet = right.getResourceSet();
697
698 assertNotNull(leftSet);
699 assertNotNull(originSet);
700 assertNotNull(rightSet);
701
702 EcoreUtil.resolveAll(leftSet);
703 EcoreUtil.resolveAll(originSet);
704 EcoreUtil.resolveAll(rightSet);
705
706 assertEquals(2, leftSet.getResources().size());
707 assertEquals(1, originSet.getResources().size());
708 assertEquals(1, rightSet.getResources().size());
709
710 IComparisonScope scope = new DefaultComparisonScope(leftSet, rightSet, originSet);
711 Comparison comparison = EMFCompare.builder().build().compare(scope);
712 testH(TestKind.ADD, comparison);
713
714 scope = new DefaultComparisonScope(rightSet, leftSet, originSet);
715 comparison = EMFCompare.builder().build().compare(scope);
716 testH(TestKind.ADD, comparison);
717 }
718
719 private void testH(TestKind testKind, Comparison comparison) {
720
721 EList<Diff> differences = comparison.getDifferences();
722 Collection<Diff> racs = Collections2.filter(differences, Predicates
723 .instanceOf(ResourceAttachmentChange.class));
724 assertEquals(1, racs.size());
725 Diff rac = racs.iterator().next();
726
727 Predicate<? super Diff> deleteFragmentedDiffDescription = null;
728 Predicate<? super Diff> deleteInnerNodeDiffDescription = null;
729
730 if (testKind == TestKind.DELETE) {
731 deleteFragmentedDiffDescription = removed("root.fragmented"); //$NON-NLS-1$
732 deleteInnerNodeDiffDescription = removed("root.fragmented.innerNode"); //$NON-NLS-1$
733 } else {
734 deleteFragmentedDiffDescription = added("root.fragmented"); //$NON-NLS-1$
735 deleteInnerNodeDiffDescription = added("root.fragmented.innerNode"); //$NON-NLS-1$
736 }
737
738 final Diff deleteFragmentedDiff = Iterators.find(differences.iterator(),
739 deleteFragmentedDiffDescription);
740 final Diff deleteInnerNodeDiff = Iterators.find(differences.iterator(),
741 deleteInnerNodeDiffDescription);
742
743 if (testKind == TestKind.DELETE) {
744 assertEquals(1, rac.getRequiredBy().size());
745 assertEquals(deleteFragmentedDiff, rac.getRequiredBy().get(0));
746 assertEquals(0, rac.getRequires().size());
747
748 assertEquals(1, deleteInnerNodeDiff.getRequiredBy().size());
749 assertEquals(deleteFragmentedDiff, deleteInnerNodeDiff.getRequiredBy().get(0));
750 assertEquals(0, deleteInnerNodeDiff.getRequires().size());
751 } else {
752 assertEquals(1, rac.getRequires().size());
753 assertEquals(deleteFragmentedDiff, rac.getRequires().get(0));
754 assertEquals(0, rac.getRequiredBy().size());
755
756 assertEquals(1, deleteInnerNodeDiff.getRequires().size());
757 assertEquals(deleteFragmentedDiff, deleteInnerNodeDiff.getRequires().get(0));
758 assertEquals(0, deleteInnerNodeDiff.getRequiredBy().size());
759 }
760 }
761
762 private void testAB1(TestKind kind, final Comparison comparison) {
763 final List<Diff> differences = comparison.getDifferences();
764
765 // We should have no less and no more than 3 differences
766 assertEquals(3, differences.size());
767
768 Predicate<? super Diff> deleteSourceDiffDescription = null;
769 Predicate<? super Diff> deleteDestinationDiffDescription = null;
770 Predicate<? super Diff> changedSingleValuedRefDiffDescription = null;
771
772 if (kind.equals(TestKind.DELETE)) {
773 deleteSourceDiffDescription = removed("Requirements.containerSource.source"); //$NON-NLS-1$
774
775 deleteDestinationDiffDescription = removed("Requirements.containerDestination.destination"); //$NON-NLS-1$
776
777 changedSingleValuedRefDiffDescription = changedReference("Requirements.containerSource.source", //$NON-NLS-1$
778 "singleValuedReference", "Requirements.containerDestination.destination", null); //$NON-NLS-1$//$NON-NLS-2$
779 } else {
780 deleteSourceDiffDescription = added("Requirements.containerSource.source"); //$NON-NLS-1$
781
782 deleteDestinationDiffDescription = added("Requirements.containerDestination.destination"); //$NON-NLS-1$
783
784 changedSingleValuedRefDiffDescription = changedReference("Requirements.containerSource.source", //$NON-NLS-1$
785 "singleValuedReference", null, "Requirements.containerDestination.destination"); //$NON-NLS-1$//$NON-NLS-2$
786 }
787
788 final Diff deleteSourceDiff = Iterators.find(differences.iterator(), deleteSourceDiffDescription);
789
790 final Diff deleteDestinationDiff = Iterators.find(differences.iterator(),
791 deleteDestinationDiffDescription);
792
793 final Diff changedSingleValuedRefDiff = Iterators.find(differences.iterator(),
794 changedSingleValuedRefDiffDescription);
795
796 assertNotNull(deleteSourceDiff);
797 assertNotNull(deleteDestinationDiff);
798 assertNotNull(changedSingleValuedRefDiff);
799
800 // CHECK REQUIREMENT
801 if (kind.equals(TestKind.ADD)) {
802 assertEquals(0, deleteSourceDiff.getRequires().size());
803
804 assertEquals(0, deleteDestinationDiff.getRequires().size());
805
806 assertEquals(2, changedSingleValuedRefDiff.getRequires().size());
807 assertTrue(changedSingleValuedRefDiff.getRequires().contains(deleteDestinationDiff));
808 assertTrue(changedSingleValuedRefDiff.getRequires().contains(deleteSourceDiff));
809 } else {
810 assertEquals(1, deleteSourceDiff.getRequires().size());
811
812 assertEquals(1, deleteDestinationDiff.getRequires().size());
813
814 assertEquals(0, changedSingleValuedRefDiff.getRequires().size());
815 }
816 }
817
818 private void testAB2(TestKind kind, final Comparison comparison) {
819 final List<Diff> differences = comparison.getDifferences();
820
821 // We should have no less and no more than 3 differences
822 assertEquals(3, differences.size());
823
824 Predicate<? super Diff> deleteSourceDiffDescription = null;
825 Predicate<? super Diff> deleteDestinationDiffDescription = null;
826 Predicate<? super Diff> deleteMultiValuedRefDiffDescription = null;
827 if (kind.equals(TestKind.DELETE)) {
828 deleteSourceDiffDescription = removed("Requirements.containerSource.source"); //$NON-NLS-1$
829 deleteDestinationDiffDescription = removed("Requirements.containerDestination.destination"); //$NON-NLS-1$
830 deleteMultiValuedRefDiffDescription = removedFromReference("Requirements.containerSource.source", //$NON-NLS-1$
831 "multiValuedReference", "Requirements.containerDestination.destination"); //$NON-NLS-1$//$NON-NLS-2$
832 } else {
833 deleteSourceDiffDescription = added("Requirements.containerSource.source"); //$NON-NLS-1$
834 deleteDestinationDiffDescription = added("Requirements.containerDestination.destination"); //$NON-NLS-1$
835 deleteMultiValuedRefDiffDescription = addedToReference("Requirements.containerSource.source", //$NON-NLS-1$
836 "multiValuedReference", "Requirements.containerDestination.destination"); //$NON-NLS-1$ //$NON-NLS-2$
837 }
838
839 final Diff deleteSourceDiff = Iterators.find(differences.iterator(), deleteSourceDiffDescription);
840
841 final Diff deleteDestinationDiff = Iterators.find(differences.iterator(),
842 deleteDestinationDiffDescription);
843
844 final Diff deleteMultiValuedRefDiff = Iterators.find(differences.iterator(),
845 deleteMultiValuedRefDiffDescription);
846
847 assertNotNull(deleteSourceDiff);
848 assertNotNull(deleteDestinationDiff);
849 assertNotNull(deleteMultiValuedRefDiff);
850
851 // CHECK REQUIREMENT
852 if (kind.equals(TestKind.ADD)) {
853 assertEquals(0, deleteSourceDiff.getRequires().size());
854
855 assertEquals(0, deleteDestinationDiff.getRequires().size());
856
857 assertEquals(2, deleteMultiValuedRefDiff.getRequires().size());
858 assertTrue(deleteMultiValuedRefDiff.getRequires().contains(deleteDestinationDiff));
859 assertTrue(deleteMultiValuedRefDiff.getRequires().contains(deleteSourceDiff));
860 } else {
861 assertEquals(1, deleteSourceDiff.getRequires().size());
862 assertTrue(deleteSourceDiff.getRequires().contains(deleteMultiValuedRefDiff));
863
864 assertEquals(1, deleteDestinationDiff.getRequires().size());
865 assertTrue(deleteDestinationDiff.getRequires().contains(deleteMultiValuedRefDiff));
866
867 assertEquals(0, deleteMultiValuedRefDiff.getRequires().size());
868 }
869 }
870
871 private void testAB3(TestKind kind, final Comparison comparison) {
872 final List<Diff> differences = comparison.getDifferences();
873
874 // We should have no less and no more than 2 differences
875 assertEquals(2, differences.size());
876
877 Predicate<? super Diff> deleteDestinationDiffDescription = null;
878 Predicate<? super Diff> changedSingleValuedRefDiffDescription = null;
879 if (kind.equals(TestKind.DELETE)) {
880 deleteDestinationDiffDescription = removed("Requirements.containerDestination.destination2"); //$NON-NLS-1$
881 changedSingleValuedRefDiffDescription = changedReference("Requirements.containerSource.source", //$NON-NLS-1$
882 "singleValuedReference", "Requirements.containerDestination.destination2", //$NON-NLS-1$ //$NON-NLS-2$
883 "Requirements.destination1"); //$NON-NLS-1$
884 } else {
885 deleteDestinationDiffDescription = added("Requirements.containerDestination.destination2"); //$NON-NLS-1$
886 changedSingleValuedRefDiffDescription = changedReference("Requirements.containerSource.source", //$NON-NLS-1$
887 "singleValuedReference", "Requirements.destination1", //$NON-NLS-1$ //$NON-NLS-2$
888 "Requirements.containerDestination.destination2"); //$NON-NLS-1$
889 }
890
891 final Diff deleteDestinationDiff = Iterators.find(differences.iterator(),
892 deleteDestinationDiffDescription);
893
894 final Diff changedSingleValuedRefDiff = Iterators.find(differences.iterator(),
895 changedSingleValuedRefDiffDescription);
896
897 assertNotNull(deleteDestinationDiff);
898 assertNotNull(changedSingleValuedRefDiff);
899
900 // CHECK REQUIREMENT
901 if (kind.equals(TestKind.ADD)) {
902 assertEquals(0, deleteDestinationDiff.getRequires().size());
903
904 assertEquals(1, changedSingleValuedRefDiff.getRequires().size());
905 assertTrue(changedSingleValuedRefDiff.getRequires().contains(deleteDestinationDiff));
906 } else {
907 assertEquals(1, deleteDestinationDiff.getRequires().size());
908 assertTrue(deleteDestinationDiff.getRequires().contains(changedSingleValuedRefDiff));
909
910 assertEquals(0, changedSingleValuedRefDiff.getRequires().size());
911 }
912 }
913
914 private void testAB4(TestKind kind, final Comparison comparison) {
915 final List<Diff> differences = comparison.getDifferences();
916
917 // We should have no less and no more than 3 differences
918 assertEquals(3, differences.size());
919
920 Predicate<? super Diff> deleteDestinationDiffDescription = null;
921 Predicate<? super Diff> deletedMultiValuedRefDiffDescription = null;
922 Predicate<? super Diff> addedMultiValuedRefDiffDescription = null;
923 if (kind.equals(TestKind.DELETE)) {
924 deleteDestinationDiffDescription = removed("Requirements.containerDestination.destination2"); //$NON-NLS-1$
925 deletedMultiValuedRefDiffDescription = removedFromReference(
926 "Requirements.containerSource.source", "multiValuedReference", //$NON-NLS-1$ //$NON-NLS-2$
927 "Requirements.containerDestination.destination2"); //$NON-NLS-1$
928 addedMultiValuedRefDiffDescription = addedToReference("Requirements.containerSource.source", //$NON-NLS-1$
929 "multiValuedReference", "Requirements.destination1"); //$NON-NLS-1$//$NON-NLS-2$
930 } else {
931 deleteDestinationDiffDescription = added("Requirements.containerDestination.destination2"); //$NON-NLS-1$
932 deletedMultiValuedRefDiffDescription = addedToReference("Requirements.containerSource.source", //$NON-NLS-1$
933 "multiValuedReference", "Requirements.containerDestination.destination2"); //$NON-NLS-1$ //$NON-NLS-2$
934 addedMultiValuedRefDiffDescription = removedFromReference("Requirements.containerSource.source", //$NON-NLS-1$
935 "multiValuedReference", "Requirements.destination1"); //$NON-NLS-1$ //$NON-NLS-2$
936 }
937
938 final Diff deleteDestinationDiff = Iterators.find(differences.iterator(),
939 deleteDestinationDiffDescription);
940
941 final Diff deletedMultiValuedRefDiff = Iterators.find(differences.iterator(),
942 deletedMultiValuedRefDiffDescription);
943
944 final Diff addedMultiValuedRefDiff = Iterators.find(differences.iterator(),
945 addedMultiValuedRefDiffDescription);
946
947 assertNotNull(deleteDestinationDiff);
948 assertNotNull(deletedMultiValuedRefDiff);
949 assertNotNull(addedMultiValuedRefDiffDescription);
950
951 // CHECK REQUIREMENT
952 if (kind.equals(TestKind.ADD)) {
953 assertEquals(0, deleteDestinationDiff.getRequires().size());
954
955 assertEquals(1, deletedMultiValuedRefDiff.getRequires().size());
956
957 assertEquals(0, addedMultiValuedRefDiff.getRequires().size());
958 assertTrue(deletedMultiValuedRefDiff.getRequires().contains(deleteDestinationDiff));
959 } else {
960 assertEquals(1, deleteDestinationDiff.getRequires().size());
961 assertTrue(deleteDestinationDiff.getRequires().contains(deletedMultiValuedRefDiff));
962
963 assertEquals(0, deletedMultiValuedRefDiff.getRequires().size());
964
965 assertEquals(0, addedMultiValuedRefDiff.getRequires().size());
966 }
967
968 }
969
970 private void testAB5(TestKind kind, final Comparison comparison) {
971 final List<Diff> differences = comparison.getDifferences();
972
973 // We should have no less and no more than 8 differences
974 assertEquals(8, differences.size());
975
976 Predicate<? super Diff> addDest4Description = null;
977 Predicate<? super Diff> delDest2Description = null;
978 Predicate<? super Diff> delDest3Description = null;
979 Predicate<? super Diff> addRefDest1Description = null;
980 Predicate<? super Diff> addRefDest4Description = null;
981 Predicate<? super Diff> delRefDest2Description = null;
982 Predicate<? super Diff> delRefDest3Description = null;
983 Predicate<? super Diff> delRefDest5Description = null;
984
985 if (kind.equals(TestKind.DELETE)) {
986 addDest4Description = added("Requirements.destination4"); //$NON-NLS-1$
987 delDest2Description = removed("Requirements.containerDestination.destination2"); //$NON-NLS-1$
988 delDest3Description = removed("Requirements.containerDestination.destination3"); //$NON-NLS-1$
989
990 addRefDest1Description = addedToReference("Requirements.containerSource.source", //$NON-NLS-1$
991 "multiValuedReference", "Requirements.destination1"); //$NON-NLS-1$ //$NON-NLS-2$
992 addRefDest4Description = addedToReference("Requirements.containerSource.source", //$NON-NLS-1$
993 "multiValuedReference", "Requirements.destination4"); //$NON-NLS-1$//$NON-NLS-2$
994 delRefDest2Description = removedFromReference("Requirements.containerSource.source", //$NON-NLS-1$
995 "multiValuedReference", "Requirements.containerDestination.destination2"); //$NON-NLS-1$ //$NON-NLS-2$
996 delRefDest3Description = removedFromReference("Requirements.containerSource.source", //$NON-NLS-1$
997 "multiValuedReference", "Requirements.containerDestination.destination3"); //$NON-NLS-1$ //$NON-NLS-2$
998 delRefDest5Description = removedFromReference("Requirements.containerSource.source", //$NON-NLS-1$
999 "multiValuedReference", "Requirements.destination5"); //$NON-NLS-1$ //$NON-NLS-2$
1000 } else {
1001 addDest4Description = removed("Requirements.destination4"); //$NON-NLS-1$
1002 delDest2Description = added("Requirements.containerDestination.destination2"); //$NON-NLS-1$
1003 delDest3Description = added("Requirements.containerDestination.destination3"); //$NON-NLS-1$
1004
1005 addRefDest1Description = removedFromReference("Requirements.containerSource.source", //$NON-NLS-1$
1006 "multiValuedReference", "Requirements.destination1"); //$NON-NLS-1$//$NON-NLS-2$
1007 addRefDest4Description = removedFromReference("Requirements.containerSource.source", //$NON-NLS-1$
1008 "multiValuedReference", "Requirements.destination4"); //$NON-NLS-1$//$NON-NLS-2$
1009 delRefDest2Description = addedToReference("Requirements.containerSource.source", //$NON-NLS-1$
1010 "multiValuedReference", "Requirements.containerDestination.destination2"); //$NON-NLS-1$//$NON-NLS-2$
1011 delRefDest3Description = addedToReference("Requirements.containerSource.source", //$NON-NLS-1$
1012 "multiValuedReference", "Requirements.containerDestination.destination3"); //$NON-NLS-1$ //$NON-NLS-2$
1013 delRefDest5Description = addedToReference("Requirements.containerSource.source", //$NON-NLS-1$
1014 "multiValuedReference", "Requirements.destination5"); //$NON-NLS-1$//$NON-NLS-2$
1015 }
1016
1017 final Diff addDest4 = Iterators.find(differences.iterator(), addDest4Description);
1018 final Diff delDest2 = Iterators.find(differences.iterator(), delDest2Description);
1019 final Diff delDest3 = Iterators.find(differences.iterator(), delDest3Description);
1020
1021 final Diff addRefDest1 = Iterators.find(differences.iterator(), addRefDest1Description);
1022 final Diff addRefDest4 = Iterators.find(differences.iterator(), addRefDest4Description);
1023 final Diff delRefDest2 = Iterators.find(differences.iterator(), delRefDest2Description);
1024 final Diff delRefDest3 = Iterators.find(differences.iterator(), delRefDest3Description);
1025 final Diff delRefDest5 = Iterators.find(differences.iterator(), delRefDest5Description);
1026
1027 assertNotNull(addDest4);
1028 assertNotNull(delDest2);
1029 assertNotNull(delDest3);
1030 assertNotNull(addRefDest1);
1031 assertNotNull(addRefDest4);
1032 assertNotNull(delRefDest2);
1033 assertNotNull(delRefDest3);
1034 assertNotNull(delRefDest5);
1035
1036 // CHECK REQUIREMENT
1037 if (kind.equals(TestKind.ADD)) {
1038 assertEquals(1, addDest4.getRequires().size());
1039 assertTrue(addDest4.getRequires().contains(addRefDest4));
1040
1041 assertEquals(0, delDest2.getRequires().size());
1042
1043 assertEquals(0, delDest3.getRequires().size());
1044
1045 assertEquals(0, addRefDest1.getRequires().size());
1046
1047 assertEquals(0, addRefDest4.getRequires().size());
1048
1049 assertEquals(1, delRefDest2.getRequires().size());
1050 assertTrue(delRefDest2.getRequires().contains(delDest2));
1051
1052 assertEquals(1, delRefDest3.getRequires().size());
1053 assertTrue(delRefDest3.getRequires().contains(delDest3));
1054
1055 assertEquals(0, delRefDest5.getRequires().size());
1056
1057 } else {
1058 assertEquals(0, addDest4.getRequires().size());
1059
1060 assertEquals(1, delDest2.getRequires().size());
1061 assertTrue(delDest2.getRequires().contains(delRefDest2));
1062
1063 assertEquals(1, delDest3.getRequires().size());
1064 assertTrue(delDest3.getRequires().contains(delRefDest3));
1065
1066 assertEquals(0, addRefDest1.getRequires().size());
1067
1068 assertEquals(1, addRefDest4.getRequires().size());
1069 assertTrue(addRefDest4.getRequires().contains(addDest4));
1070
1071 assertEquals(0, delRefDest2.getRequires().size());
1072
1073 assertEquals(0, delRefDest3.getRequires().size());
1074
1075 assertEquals(0, delRefDest5.getRequires().size());
1076 }
1077
1078 }
1079
1080 private void testAB6(TestKind kind, final Comparison comparison) {
1081 final List<Diff> differences = comparison.getDifferences();
1082
1083 // We should have no less and no more than 7 differences
1084 assertEquals(7, differences.size());
1085
1086 Predicate<? super Diff> delDestDescription = null;
1087 Predicate<? super Diff> delContainerDescription = null;
1088 Predicate<? super Diff> delSubContainerDescription = null;
1089 Predicate<? super Diff> delSource1Description = null;
1090 Predicate<? super Diff> delSource2Description = null;
1091 Predicate<? super Diff> delRefSource1Description = null;
1092 Predicate<? super Diff> delRefSource2Description = null;
1093
1094 if (kind.equals(TestKind.DELETE)) {
1095 delDestDescription = removed("Requirements.destination"); //$NON-NLS-1$
1096 delContainerDescription = removed("Requirements.container"); //$NON-NLS-1$
1097 delSubContainerDescription = removed("Requirements.container.subContainer"); //$NON-NLS-1$
1098 delSource1Description = removed("Requirements.container.subContainer.source1"); //$NON-NLS-1$
1099 delSource2Description = removed("Requirements.container.subContainer.source2"); //$NON-NLS-1$
1100
1101 delRefSource1Description = changedReference("Requirements.container.subContainer.source1", //$NON-NLS-1$
1102 "singleValuedReference", "Requirements.destination", null); //$NON-NLS-1$//$NON-NLS-2$
1103 delRefSource2Description = removedFromReference("Requirements.container.subContainer.source2", //$NON-NLS-1$
1104 "multiValuedReference", "Requirements.destination"); //$NON-NLS-1$ //$NON-NLS-2$
1105 } else {
1106 delDestDescription = added("Requirements.destination"); //$NON-NLS-1$
1107 delContainerDescription = added("Requirements.container"); //$NON-NLS-1$
1108 delSubContainerDescription = added("Requirements.container.subContainer"); //$NON-NLS-1$
1109 delSource1Description = added("Requirements.container.subContainer.source1"); //$NON-NLS-1$
1110 delSource2Description = added("Requirements.container.subContainer.source2"); //$NON-NLS-1$
1111
1112 delRefSource1Description = changedReference("Requirements.container.subContainer.source1", //$NON-NLS-1$
1113 "singleValuedReference", null, "Requirements.destination"); //$NON-NLS-1$ //$NON-NLS-2$
1114 delRefSource2Description = addedToReference("Requirements.container.subContainer.source2", //$NON-NLS-1$
1115 "multiValuedReference", "Requirements.destination"); //$NON-NLS-1$//$NON-NLS-2$
1116 }
1117
1118 final Diff delDest = Iterators.find(differences.iterator(), delDestDescription);
1119 final Diff delContainer = Iterators.find(differences.iterator(), delContainerDescription);
1120 final Diff delSubContainer = Iterators.find(differences.iterator(), delSubContainerDescription);
1121 final Diff delSource1 = Iterators.find(differences.iterator(), delSource1Description);
1122 final Diff delSource2 = Iterators.find(differences.iterator(), delSource2Description);
1123 final Diff delRefSource1 = Iterators.find(differences.iterator(), delRefSource1Description);
1124 final Diff delRefSource2 = Iterators.find(differences.iterator(), delRefSource2Description);
1125
1126 assertNotNull(delDest);
1127 assertNotNull(delContainer);
1128 assertNotNull(delSubContainer);
1129 assertNotNull(delSource1);
1130 assertNotNull(delSource2);
1131 assertNotNull(delRefSource1);
1132 assertNotNull(delRefSource2);
1133
1134 // CHECK REQUIREMENT
1135 if (kind.equals(TestKind.ADD)) {
1136 assertEquals(0, delDest.getRequires().size());
1137
1138 assertEquals(0, delContainer.getRequires().size());
1139
1140 assertEquals(1, delSubContainer.getRequires().size());
1141 assertTrue(delSubContainer.getRequires().contains(delContainer));
1142
1143 assertEquals(1, delSource1.getRequires().size());
1144 assertTrue(delSource1.getRequires().contains(delSubContainer));
1145
1146 assertEquals(1, delSource2.getRequires().size());
1147 assertTrue(delSource2.getRequires().contains(delSubContainer));
1148
1149 assertEquals(2, delRefSource1.getRequires().size());
1150 assertTrue(delRefSource1.getRequires().contains(delSource1));
1151 assertTrue(delRefSource2.getRequires().contains(delSource2));
1152
1153 assertEquals(2, delRefSource2.getRequires().size());
1154 assertTrue(delRefSource1.getRequires().contains(delDest));
1155 assertTrue(delRefSource2.getRequires().contains(delDest));
1156 } else {
1157 assertEquals(2, delDest.getRequires().size());
1158 assertTrue(delDest.getRequires().contains(delRefSource1));
1159 assertTrue(delDest.getRequires().contains(delRefSource2));
1160
1161 assertEquals(1, delContainer.getRequires().size());
1162 assertTrue(delContainer.getRequires().contains(delSubContainer));
1163
1164 assertEquals(2, delSubContainer.getRequires().size());
1165 assertTrue(delSubContainer.getRequires().contains(delSource1));
1166 assertTrue(delSubContainer.getRequires().contains(delSource2));
1167
1168 assertEquals(1, delSource1.getRequires().size());
1169 assertTrue(delSource1.getRequires().contains(delRefSource1));
1170
1171 assertEquals(1, delSource2.getRequires().size());
1172 assertTrue(delSource2.getRequires().contains(delRefSource2));
1173
1174 assertEquals(0, delRefSource1.getRequires().size());
1175
1176 assertEquals(0, delRefSource2.getRequires().size());
1177 }
1178
1179 }
1180
1181 private void testAB7(TestKind kind, final Comparison comparison) {
1182 final List<Diff> differences = comparison.getDifferences();
1183
1184 // We should have no less and no more than 4 differences
1185 assertEquals(4, differences.size());
1186
1187 Predicate<? super Diff> addBDescription = null;
1188 Predicate<? super Diff> delCDescription = null;
1189 Predicate<? super Diff> addEDescription = null;
1190 Predicate<? super Diff> delFDescription = null;
1191
1192 if (kind.equals(TestKind.ADD)) {
1193 addBDescription = added("Requirements.A.B"); //$NON-NLS-1$
1194 delCDescription = removed("Requirements.A.C"); //$NON-NLS-1$
1195 addEDescription = added("Requirements.D.E"); //$NON-NLS-1$
1196 delFDescription = removed("Requirements.D.F"); //$NON-NLS-1$
1197 } else {
1198 addBDescription = removed("Requirements.A.B"); //$NON-NLS-1$
1199 delCDescription = added("Requirements.A.C"); //$NON-NLS-1$
1200 addEDescription = removed("Requirements.D.E"); //$NON-NLS-1$
1201 delFDescription = added("Requirements.D.F"); //$NON-NLS-1$
1202 }
1203
1204 final Diff addB = Iterators.find(differences.iterator(), addBDescription);
1205 final Diff delC = Iterators.find(differences.iterator(), delCDescription);
1206 final Diff addE = Iterators.find(differences.iterator(), addEDescription);
1207 final Diff delF = Iterators.find(differences.iterator(), delFDescription);
1208
1209 assertNotNull(addB);
1210 assertNotNull(delC);
1211 assertNotNull(addE);
1212 assertNotNull(delF);
1213
1214 // CHECK REQUIREMENT
1215 if (kind.equals(TestKind.ADD)) {
1216 assertEquals(1, addB.getRequires().size());
1217 assertTrue(addB.getRequires().contains(delC));
1218
1219 assertEquals(0, delC.getRequires().size());
1220
1221 assertEquals(0, addE.getRequires().size());
1222
1223 assertEquals(0, delF.getRequires().size());
1224 } else {
1225 assertEquals(0, addB.getRequires().size());
1226
1227 assertEquals(1, delC.getRequires().size());
1228 assertTrue(delC.getRequires().contains(addB));
1229
1230 assertEquals(0, addE.getRequires().size());
1231
1232 assertEquals(0, delF.getRequires().size());
1233 }
1234
1235 }
1236
1237 private void testAB8(TestKind kind, final Comparison comparison) {
1238 final List<Diff> differences = comparison.getDifferences();
1239
1240 // We should have no less and no more than 7 differences
1241 assertEquals(7, differences.size());
1242
1243 Predicate<? super Diff> addBDescription = null;
1244 Predicate<? super Diff> delCDescription = null;
1245 Predicate<? super Diff> changeRefBDescription = null;
1246 Predicate<? super Diff> addEDescription = null;
1247 Predicate<? super Diff> delFDescription = null;
1248 Predicate<? super Diff> addRefEDescription = null;
1249 Predicate<? super Diff> delRefFDescription = null;
1250
1251 if (kind.equals(TestKind.ADD)) {
1252 addBDescription = added("Requirements.B"); //$NON-NLS-1$
1253 delCDescription = removed("Requirements.C"); //$NON-NLS-1$
1254 changeRefBDescription = changedReference(
1255 "Requirements.A", "singleValuedReference", "Requirements.C", "Requirements.B"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
1256 addEDescription = added("Requirements.E"); //$NON-NLS-1$
1257 delFDescription = removed("Requirements.F"); //$NON-NLS-1$
1258 addRefEDescription = addedToReference("Requirements.D", "multiValuedReference", "Requirements.E"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
1259 delRefFDescription = removedFromReference(
1260 "Requirements.D", "multiValuedReference", "Requirements.F"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
1261 } else {
1262 addBDescription = removed("Requirements.B"); //$NON-NLS-1$
1263 delCDescription = added("Requirements.C"); //$NON-NLS-1$
1264 changeRefBDescription = changedReference(
1265 "Requirements.A", "singleValuedReference", "Requirements.B", "Requirements.C"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
1266 addEDescription = removed("Requirements.E"); //$NON-NLS-1$
1267 delFDescription = added("Requirements.F"); //$NON-NLS-1$
1268 addRefEDescription = removedFromReference(
1269 "Requirements.D", "multiValuedReference", "Requirements.E"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
1270 delRefFDescription = addedToReference("Requirements.D", "multiValuedReference", "Requirements.F"); //$NON-NLS-1$//$NON-NLS-2$ //$NON-NLS-3$
1271 }
1272
1273 final Diff addB = Iterators.find(differences.iterator(), addBDescription);
1274 final Diff delC = Iterators.find(differences.iterator(), delCDescription);
1275 final Diff changeRefB = Iterators.find(differences.iterator(), changeRefBDescription);
1276 final Diff addE = Iterators.find(differences.iterator(), addEDescription);
1277 final Diff delF = Iterators.find(differences.iterator(), delFDescription);
1278 final Diff addRefE = Iterators.find(differences.iterator(), addRefEDescription);
1279 final Diff delRefF = Iterators.find(differences.iterator(), delRefFDescription);
1280
1281 assertNotNull(addB);
1282 assertNotNull(delC);
1283 assertNotNull(changeRefB);
1284 assertNotNull(addE);
1285 assertNotNull(delF);
1286 assertNotNull(addRefE);
1287 assertNotNull(delRefF);
1288
1289 // CHECK REQUIREMENT
1290 if (kind.equals(TestKind.ADD)) {
1291 assertEquals(0, addB.getRequires().size());
1292
1293 assertEquals(1, delC.getRequires().size());
1294 assertTrue(delC.getRequires().contains(changeRefB));
1295
1296 assertEquals(1, changeRefB.getRequires().size());
1297 assertTrue(changeRefB.getRequires().contains(addB));
1298
1299 assertEquals(0, addE.getRequires().size());
1300
1301 assertEquals(1, delF.getRequires().size());
1302 assertTrue(delF.getRequires().contains(delRefF));
1303
1304 assertEquals(1, addRefE.getRequires().size());
1305 assertTrue(addRefE.getRequires().contains(addE));
1306
1307 assertEquals(0, delRefF.getRequires().size());
1308 } else {
1309 assertEquals(1, addB.getRequires().size());
1310 assertTrue(addB.getRequires().contains(changeRefB));
1311
1312 assertEquals(0, delC.getRequires().size());
1313
1314 assertEquals(1, changeRefB.getRequires().size());
1315 assertTrue(changeRefB.getRequires().contains(delC));
1316
1317 assertEquals(1, addE.getRequires().size());
1318 assertTrue(addE.getRequires().contains(addRefE));
1319
1320 assertEquals(0, delF.getRequires().size());
1321
1322 assertEquals(0, addRefE.getRequires().size());
1323
1324 assertEquals(1, delRefF.getRequires().size());
1325 assertTrue(delRefF.getRequires().contains(delF));
1326 }
1327
1328 }
1329
1330 private void testAB9(TestKind kind, final Comparison comparison) {
1331 final List<Diff> differences = comparison.getDifferences();
1332
1333 // We should have no less and no more than 2 differences
1334 assertEquals(2, differences.size());
1335
1336 Predicate<? super Diff> addBDescription = null;
1337 Predicate<? super Diff> addCDescription = null;
1338
1339 if (kind.equals(TestKind.ADD)) {
1340 addBDescription = added("Requirements.A.B"); //$NON-NLS-1$
1341 addCDescription = added("Requirements.A.B.C"); //$NON-NLS-1$
1342 } else {
1343 addBDescription = removed("Requirements.A.B"); //$NON-NLS-1$
1344 addCDescription = removed("Requirements.A.B.C"); //$NON-NLS-1$
1345 }
1346
1347 final Diff addB = Iterators.find(differences.iterator(), addBDescription);
1348 final Diff addC = Iterators.find(differences.iterator(), addCDescription);
1349
1350 assertNotNull(addB);
1351 assertNotNull(addC);
1352
1353 // CHECK REQUIREMENT
1354 if (kind.equals(TestKind.ADD)) {
1355 assertEquals(0, addB.getRequires().size());
1356
1357 assertEquals(1, addC.getRequires().size());
1358 assertTrue(addC.getRequires().contains(addB));
1359 } else {
1360 assertEquals(1, addB.getRequires().size());
1361 assertTrue(addB.getRequires().contains(addC));
1362
1363 assertEquals(0, addC.getRequires().size());
1364 }
1365
1366 }
1367
1368 private void testAB10(TestKind kind, final Comparison comparison) {
1369 final List<Diff> differences = comparison.getDifferences();
1370
1371 // We should have no less and no more than 4 differences
1372 assertEquals(4, differences.size());
1373
1374 Predicate<? super Diff> addADescription = null;
1375 Predicate<? super Diff> addCDescription = null;
1376 Predicate<? super Diff> changeRefBDescription = null;
1377 Predicate<? super Diff> addRefBDescription = null;
1378
1379 if (kind.equals(TestKind.ADD)) {
1380 addADescription = added("Requirements.A"); //$NON-NLS-1$
1381 addCDescription = added("Requirements.C"); //$NON-NLS-1$
1382 changeRefBDescription = changedReference("Requirements.A", "singleValuedReference", null,
1383 "Requirements.B");
1384 addRefBDescription = addedToReference("Requirements.C", "multiValuedReference", "Requirements.B");
1385 } else {
1386 addADescription = removed("Requirements.A"); //$NON-NLS-1$
1387 addCDescription = removed("Requirements.C"); //$NON-NLS-1$
1388 changeRefBDescription = changedReference("Requirements.A", "singleValuedReference",
1389 "Requirements.B", null);
1390 addRefBDescription = removedFromReference("Requirements.C", "multiValuedReference",
1391 "Requirements.B");
1392 }
1393
1394 final Diff addA = Iterators.find(differences.iterator(), addADescription);
1395 final Diff addC = Iterators.find(differences.iterator(), addCDescription);
1396 final Diff changeRefB = Iterators.find(differences.iterator(), changeRefBDescription);
1397 final Diff addRefB = Iterators.find(differences.iterator(), addRefBDescription);
1398
1399 assertNotNull(addA);
1400 assertNotNull(addC);
1401 assertNotNull(changeRefB);
1402 assertNotNull(addRefB);
1403
1404 // CHECK REQUIREMENT
1405 if (kind.equals(TestKind.ADD)) {
1406 assertEquals(0, addA.getRequires().size());
1407
1408 assertEquals(0, addC.getRequires().size());
1409
1410 assertEquals(1, changeRefB.getRequires().size());
1411 assertTrue(changeRefB.getRequires().contains(addA));
1412
1413 assertEquals(1, addRefB.getRequires().size());
1414 assertTrue(addRefB.getRequires().contains(addC));
1415 } else {
1416 assertEquals(1, addA.getRequires().size());
1417 assertTrue(addA.getRequires().contains(changeRefB));
1418
1419 assertEquals(1, addC.getRequires().size());
1420 assertTrue(addC.getRequires().contains(addRefB));
1421
1422 assertEquals(0, changeRefB.getRequires().size());
1423
1424 assertEquals(0, addRefB.getRequires().size());
1425 }
1426
1427 }
1428
1429 private void testAB11(TestKind kind, final Comparison comparison) {
1430 final List<Diff> differences = comparison.getDifferences();
1431
1432 // We should have no less and no more than 4 differences
1433 assertEquals(4, differences.size());
1434
1435 Predicate<? super Diff> delBDescription = null;
1436 Predicate<? super Diff> moveCDescription = null;
1437 Predicate<? super Diff> moveDDescription = null;
1438 Predicate<? super Diff> moveEDescription = null;
1439
1440 if (kind.equals(TestKind.ADD)) {
1441 delBDescription = removed("Requirements.A.B"); //$NON-NLS-1$
1442 moveCDescription = movedInReference("Requirements.A", "containmentRef1", "Requirements.A.C"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
1443 moveDDescription = movedInReference("Requirements.A", "containmentRef1", "Requirements.A.D"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
1444 moveEDescription = movedInReference("Requirements.A.D", "containmentRef1", "Requirements.A.D.E"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
1445 } else {
1446 delBDescription = added("Requirements.A.B"); //$NON-NLS-1$
1447 moveCDescription = movedInReference("Requirements.A.B", "containmentRef1", "Requirements.A.B.C"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
1448 moveDDescription = movedInReference("Requirements.A.E", "containmentRef1", "Requirements.A.E.D"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
1449 moveEDescription = movedInReference("Requirements.A", "containmentRef1", "Requirements.A.E"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
1450 }
1451
1452 final Diff delB = Iterators.find(differences.iterator(), delBDescription);
1453 final Diff moveC = Iterators.find(differences.iterator(), moveCDescription);
1454 final Diff moveD = Iterators.find(differences.iterator(), moveDDescription);
1455 final Diff moveE = Iterators.find(differences.iterator(), moveEDescription);
1456
1457 assertNotNull(delB);
1458 assertNotNull(moveC);
1459 assertNotNull(moveD);
1460 assertNotNull(moveE);
1461
1462 // CHECK REQUIREMENT
1463 if (kind.equals(TestKind.ADD)) {
1464 assertEquals(1, delB.getRequires().size());
1465 assertTrue(delB.getRequires().contains(moveC));
1466
1467 assertEquals(0, moveC.getRequires().size());
1468
1469 assertEquals(0, moveD.getRequires().size());
1470
1471 assertEquals(1, moveE.getRequires().size());
1472 assertTrue(moveE.getRequires().contains(moveD));
1473 } else {
1474 assertEquals(0, delB.getRequires().size());
1475
1476 assertEquals(1, moveC.getRequires().size());
1477 assertTrue(moveC.getRequires().contains(delB));
1478
1479 assertEquals(1, moveD.getRequires().size());
1480 assertTrue(moveD.getRequires().contains(moveE));
1481
1482 assertEquals(0, moveE.getRequires().size());
1483 }
1484
1485 }
1486
1487 private void testCD1(TestKind kind, final Comparison comparison) {
1488 final List<Diff> differences = comparison.getDifferences();
1489
1490 // We should have no less and no more than 5 differences
1491 assertEquals(5, differences.size());
1492
1493 Predicate<? super Diff> deleteADiffDescription = null;
1494 Predicate<? super Diff> deleteBDiffDescription = null;
1495 Predicate<? super Diff> deleteCDiffDescription = null;
1496 Predicate<? super Diff> deleteRefBDiffDescription = null;
1497 Predicate<? super Diff> deleteRefCDiffDescription = null;
1498
1499 if (kind.equals(TestKind.DELETE)) {
1500 deleteADiffDescription = removed("Requirements.A"); //$NON-NLS-1$
1501 deleteBDiffDescription = removed("Requirements.B"); //$NON-NLS-1$
1502 deleteCDiffDescription = removed("Requirements.C"); //$NON-NLS-1$
1503 deleteRefBDiffDescription = removedFromReference("Requirements.A", "multiValuedReference", //$NON-NLS-1$ //$NON-NLS-2$
1504 "Requirements.B"); //$NON-NLS-1$
1505 deleteRefCDiffDescription = removedFromReference("Requirements.A", "multiValuedReference", //$NON-NLS-1$ //$NON-NLS-2$
1506 "Requirements.C"); //$NON-NLS-1$
1507 } else {
1508 deleteADiffDescription = added("Requirements.A"); //$NON-NLS-1$
1509 deleteBDiffDescription = added("Requirements.B"); //$NON-NLS-1$
1510 deleteCDiffDescription = added("Requirements.C"); //$NON-NLS-1$
1511 deleteRefBDiffDescription = addedToReference("Requirements.A", "multiValuedReference", //$NON-NLS-1$ //$NON-NLS-2$
1512 "Requirements.B"); //$NON-NLS-1$
1513 deleteRefCDiffDescription = addedToReference("Requirements.A", "multiValuedReference", //$NON-NLS-1$ //$NON-NLS-2$
1514 "Requirements.C"); //$NON-NLS-1$
1515 }
1516
1517 final Diff deleteADiff = Iterators.find(differences.iterator(), deleteADiffDescription);
1518 final Diff deleteBDiff = Iterators.find(differences.iterator(), deleteBDiffDescription);
1519 final Diff deleteCDiff = Iterators.find(differences.iterator(), deleteCDiffDescription);
1520 final Diff deleteRefBDiff = Iterators.find(differences.iterator(), deleteRefBDiffDescription);
1521 final Diff deleteRefCDiff = Iterators.find(differences.iterator(), deleteRefCDiffDescription);
1522
1523 assertNotNull(deleteADiff);
1524 assertNotNull(deleteBDiff);
1525 assertNotNull(deleteCDiff);
1526 assertNotNull(deleteRefBDiff);
1527 assertNotNull(deleteRefCDiff);
1528
1529 // CHECK REQUIREMENT
1530 if (kind.equals(TestKind.ADD)) {
1531 assertEquals(0, deleteADiff.getRequires().size());
1532
1533 assertEquals(0, deleteBDiff.getRequires().size());
1534
1535 assertEquals(0, deleteCDiff.getRequires().size());
1536
1537 assertEquals(2, deleteRefBDiff.getRequires().size());
1538 assertTrue(deleteRefBDiff.getRequires().contains(deleteBDiff));
1539 assertTrue(deleteRefBDiff.getRequires().contains(deleteADiff));
1540
1541 assertEquals(2, deleteRefCDiff.getRequires().size());
1542 assertTrue(deleteRefCDiff.getRequires().contains(deleteCDiff));
1543 assertTrue(deleteRefCDiff.getRequires().contains(deleteADiff));
1544 } else {
1545 assertEquals(2, deleteADiff.getRequires().size());
1546 assertTrue(deleteADiff.getRequires().contains(deleteRefBDiff));
1547 assertTrue(deleteADiff.getRequires().contains(deleteRefCDiff));
1548
1549 assertEquals(1, deleteBDiff.getRequires().size());
1550 assertTrue(deleteBDiff.getRequires().contains(deleteRefBDiff));
1551
1552 assertEquals(1, deleteCDiff.getRequires().size());
1553 assertTrue(deleteCDiff.getRequires().contains(deleteRefCDiff));
1554
1555 assertEquals(0, deleteRefBDiff.getRequires().size());
1556
1557 assertEquals(0, deleteRefCDiff.getRequires().size());
1558 }
1559
1560 }
1561
1562 private void testCD2(TestKind kind, final Comparison comparison) {
1563 final List<Diff> differences = comparison.getDifferences();
1564
1565 // We should have no less and no more than 5 differences
1566 assertEquals(4, differences.size());
1567
1568 Predicate<? super Diff> deleteADiffDescription = null;
1569 Predicate<? super Diff> deleteCDiffDescription = null;
1570 Predicate<? super Diff> deleteRefBDiffDescription = null;
1571 Predicate<? super Diff> deleteRefCDiffDescription = null;
1572
1573 if (kind.equals(TestKind.DELETE)) {
1574 deleteADiffDescription = removed("Requirements.A"); //$NON-NLS-1$
1575 deleteCDiffDescription = removed("Requirements.C"); //$NON-NLS-1$
1576 deleteRefBDiffDescription = removedFromReference("Requirements.A", "multiValuedReference", //$NON-NLS-1$ //$NON-NLS-2$
1577 "Requirements.B"); //$NON-NLS-1$
1578 deleteRefCDiffDescription = removedFromReference("Requirements.A", "multiValuedReference", //$NON-NLS-1$//$NON-NLS-2$
1579 "Requirements.C"); //$NON-NLS-1$
1580 } else {
1581 deleteADiffDescription = added("Requirements.A"); //$NON-NLS-1$
1582 deleteCDiffDescription = added("Requirements.C"); //$NON-NLS-1$
1583 deleteRefBDiffDescription = addedToReference("Requirements.A", "multiValuedReference", //$NON-NLS-1$//$NON-NLS-2$
1584 "Requirements.B"); //$NON-NLS-1$
1585 deleteRefCDiffDescription = addedToReference("Requirements.A", "multiValuedReference", //$NON-NLS-1$ //$NON-NLS-2$
1586 "Requirements.C"); //$NON-NLS-1$
1587 }
1588
1589 final Diff deleteADiff = Iterators.find(differences.iterator(), deleteADiffDescription);
1590 final Diff deleteCDiff = Iterators.find(differences.iterator(), deleteCDiffDescription);
1591 final Diff deleteRefBDiff = Iterators.find(differences.iterator(), deleteRefBDiffDescription);
1592 final Diff deleteRefCDiff = Iterators.find(differences.iterator(), deleteRefCDiffDescription);
1593
1594 assertNotNull(deleteADiff);
1595 assertNotNull(deleteCDiff);
1596 assertNotNull(deleteRefBDiff);
1597 assertNotNull(deleteRefCDiff);
1598
1599 // CHECK REQUIREMENT
1600 if (kind.equals(TestKind.ADD)) {
1601 assertEquals(0, deleteADiff.getRequires().size());
1602
1603 assertEquals(0, deleteCDiff.getRequires().size());
1604
1605 assertEquals(1, deleteRefBDiff.getRequires().size());
1606 assertTrue(deleteRefBDiff.getRequires().contains(deleteADiff));
1607
1608 assertEquals(2, deleteRefCDiff.getRequires().size());
1609 assertTrue(deleteRefCDiff.getRequires().contains(deleteCDiff));
1610 assertTrue(deleteRefCDiff.getRequires().contains(deleteADiff));
1611 } else {
1612 assertEquals(2, deleteADiff.getRequires().size());
1613 assertTrue(deleteADiff.getRequires().contains(deleteRefBDiff));
1614 assertTrue(deleteADiff.getRequires().contains(deleteRefCDiff));
1615
1616 assertEquals(1, deleteCDiff.getRequires().size());
1617 assertTrue(deleteCDiff.getRequires().contains(deleteRefCDiff));
1618
1619 assertEquals(0, deleteRefBDiff.getRequires().size());
1620
1621 assertEquals(0, deleteRefCDiff.getRequires().size());
1622 }
1623
1624 }
1625
1626 private void testCD3(TestKind kind, final Comparison comparison) {
1627 final List<Diff> differences = comparison.getDifferences();
1628
1629 // We should have no less and no more than 5 differences
1630 assertEquals(4, differences.size());
1631
1632 Predicate<? super Diff> deleteBDiffDescription = null;
1633 Predicate<? super Diff> deleteCDiffDescription = null;
1634 Predicate<? super Diff> deleteRefBDiffDescription = null;
1635 Predicate<? super Diff> deleteRefCDiffDescription = null;
1636
1637 if (kind.equals(TestKind.DELETE)) {
1638 deleteBDiffDescription = removed("Requirements.B"); //$NON-NLS-1$
1639 deleteCDiffDescription = removed("Requirements.C"); //$NON-NLS-1$
1640 deleteRefBDiffDescription = removedFromReference("Requirements.A", "multiValuedReference", //$NON-NLS-1$ //$NON-NLS-2$
1641 "Requirements.B"); //$NON-NLS-1$
1642 deleteRefCDiffDescription = removedFromReference("Requirements.A", "multiValuedReference", //$NON-NLS-1$ //$NON-NLS-2$
1643 "Requirements.C"); //$NON-NLS-1$
1644 } else {
1645 deleteBDiffDescription = added("Requirements.B"); //$NON-NLS-1$
1646 deleteCDiffDescription = added("Requirements.C"); //$NON-NLS-1$
1647 deleteRefBDiffDescription = addedToReference("Requirements.A", "multiValuedReference", //$NON-NLS-1$ //$NON-NLS-2$
1648 "Requirements.B"); //$NON-NLS-1$
1649 deleteRefCDiffDescription = addedToReference("Requirements.A", "multiValuedReference", //$NON-NLS-1$ //$NON-NLS-2$
1650 "Requirements.C"); //$NON-NLS-1$
1651 }
1652
1653 final Diff deleteBDiff = Iterators.find(differences.iterator(), deleteBDiffDescription);
1654 final Diff deleteCDiff = Iterators.find(differences.iterator(), deleteCDiffDescription);
1655 final Diff deleteRefBDiff = Iterators.find(differences.iterator(), deleteRefBDiffDescription);
1656 final Diff deleteRefCDiff = Iterators.find(differences.iterator(), deleteRefCDiffDescription);
1657
1658 assertNotNull(deleteBDiff);
1659 assertNotNull(deleteCDiff);
1660 assertNotNull(deleteRefBDiff);
1661 assertNotNull(deleteRefCDiff);
1662
1663 // CHECK REQUIREMENT
1664 if (kind.equals(TestKind.ADD)) {
1665 assertEquals(0, deleteBDiff.getRequires().size());
1666
1667 assertEquals(0, deleteCDiff.getRequires().size());
1668
1669 assertEquals(1, deleteRefBDiff.getRequires().size());
1670 assertTrue(deleteRefBDiff.getRequires().contains(deleteBDiff));
1671
1672 assertEquals(1, deleteRefCDiff.getRequires().size());
1673 assertTrue(deleteRefCDiff.getRequires().contains(deleteCDiff));
1674 } else {
1675 assertEquals(1, deleteBDiff.getRequires().size());
1676 assertTrue(deleteBDiff.getRequires().contains(deleteRefBDiff));
1677
1678 assertEquals(1, deleteCDiff.getRequires().size());
1679 assertTrue(deleteCDiff.getRequires().contains(deleteRefCDiff));
1680
1681 assertEquals(0, deleteRefBDiff.getRequires().size());
1682
1683 assertEquals(0, deleteRefCDiff.getRequires().size());
1684 }
1685
1686 }
1687
1688 private void testCD4(TestKind kind, final Comparison comparison) {
1689 final List<Diff> differences = comparison.getDifferences();
1690
1691 // We should have no less and no more than 5 differences
1692 assertEquals(3, differences.size());
1693
1694 Predicate<? super Diff> deleteCDiffDescription = null;
1695 Predicate<? super Diff> deleteRefBDiffDescription = null;
1696 Predicate<? super Diff> deleteRefCDiffDescription = null;
1697
1698 if (kind.equals(TestKind.DELETE)) {
1699 deleteCDiffDescription = removed("Requirements.C"); //$NON-NLS-1$
1700 deleteRefBDiffDescription = removedFromReference("Requirements.A", "multiValuedReference", //$NON-NLS-1$//$NON-NLS-2$
1701 "Requirements.B"); //$NON-NLS-1$
1702 deleteRefCDiffDescription = removedFromReference("Requirements.A", "multiValuedReference", //$NON-NLS-1$ //$NON-NLS-2$
1703 "Requirements.C"); //$NON-NLS-1$
1704 } else {
1705 deleteCDiffDescription = added("Requirements.C"); //$NON-NLS-1$
1706 deleteRefBDiffDescription = addedToReference("Requirements.A", "multiValuedReference", //$NON-NLS-1$//$NON-NLS-2$
1707 "Requirements.B"); //$NON-NLS-1$
1708 deleteRefCDiffDescription = addedToReference("Requirements.A", "multiValuedReference", //$NON-NLS-1$//$NON-NLS-2$
1709 "Requirements.C"); //$NON-NLS-1$
1710 }
1711
1712 final Diff deleteCDiff = Iterators.find(differences.iterator(), deleteCDiffDescription);
1713 final Diff deleteRefBDiff = Iterators.find(differences.iterator(), deleteRefBDiffDescription);
1714 final Diff deleteRefCDiff = Iterators.find(differences.iterator(), deleteRefCDiffDescription);
1715
1716 assertNotNull(deleteCDiff);
1717 assertNotNull(deleteRefBDiff);
1718 assertNotNull(deleteRefCDiff);
1719
1720 // CHECK REQUIREMENT
1721 if (kind.equals(TestKind.ADD)) {
1722 assertEquals(0, deleteCDiff.getRequires().size());
1723
1724 assertEquals(0, deleteRefBDiff.getRequires().size());
1725
1726 assertEquals(1, deleteRefCDiff.getRequires().size());
1727 assertTrue(deleteRefCDiff.getRequires().contains(deleteCDiff));
1728 } else {
1729 assertEquals(1, deleteCDiff.getRequires().size());
1730 assertTrue(deleteCDiff.getRequires().contains(deleteRefCDiff));
1731
1732 assertEquals(0, deleteRefBDiff.getRequires().size());
1733
1734 assertEquals(0, deleteRefCDiff.getRequires().size());
1735 }
1736
1737 }
1738
1739 private void testCD5(TestKind kind, final Comparison comparison) {
1740 final List<Diff> differences = comparison.getDifferences();
1741
1742 // We should have no less and no more than 2 differences
1743 assertEquals(2, differences.size());
1744
1745 Predicate<? super Diff> deleteCDiffDescription = null;
1746 Predicate<? super Diff> deleteRefCDiffDescription = null;
1747
1748 if (kind.equals(TestKind.DELETE)) {
1749 deleteCDiffDescription = removed("Requirements.C"); //$NON-NLS-1$
1750 deleteRefCDiffDescription = removedFromReference("Requirements.A", "multiValuedReference", //$NON-NLS-1$//$NON-NLS-2$
1751 "Requirements.C"); //$NON-NLS-1$
1752 } else {
1753 deleteCDiffDescription = added("Requirements.C"); //$NON-NLS-1$
1754 deleteRefCDiffDescription = addedToReference("Requirements.A", "multiValuedReference", //$NON-NLS-1$//$NON-NLS-2$
1755 "Requirements.C"); //$NON-NLS-1$
1756 }
1757
1758 final Diff deleteCDiff = Iterators.find(differences.iterator(), deleteCDiffDescription);
1759 final Diff deleteRefCDiff = Iterators.find(differences.iterator(), deleteRefCDiffDescription);
1760
1761 assertNotNull(deleteCDiff);
1762 assertNotNull(deleteRefCDiff);
1763
1764 // CHECK REQUIREMENT
1765 if (kind.equals(TestKind.ADD)) {
1766 assertEquals(0, deleteCDiff.getRequires().size());
1767
1768 assertEquals(1, deleteRefCDiff.getRequires().size());
1769 assertTrue(deleteRefCDiff.getRequires().contains(deleteCDiff));
1770 } else {
1771 assertEquals(1, deleteCDiff.getRequires().size());
1772 assertTrue(deleteCDiff.getRequires().contains(deleteRefCDiff));
1773
1774 assertEquals(0, deleteRefCDiff.getRequires().size());
1775 }
1776
1777 }
1778 }
Eclipse foundation framework to comapre EMF models