| /******************************************************************************* |
| * Copyright (c) 2012, 2014 Obeo. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Obeo - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.emf.compare.uml2.tests.timeConstraint; |
| |
| import static com.google.common.base.Predicates.and; |
| import static com.google.common.base.Predicates.instanceOf; |
| import static org.eclipse.emf.compare.utils.EMFComparePredicates.added; |
| import static org.eclipse.emf.compare.utils.EMFComparePredicates.addedToReference; |
| import static org.eclipse.emf.compare.utils.EMFComparePredicates.changedReference; |
| import static org.eclipse.emf.compare.utils.EMFComparePredicates.ofKind; |
| import static org.eclipse.emf.compare.utils.EMFComparePredicates.removed; |
| import static org.eclipse.emf.compare.utils.EMFComparePredicates.removedFromReference; |
| import static org.junit.Assert.assertEquals; |
| import static org.junit.Assert.assertNotNull; |
| import static org.junit.Assert.assertTrue; |
| |
| import com.google.common.base.Predicate; |
| import com.google.common.collect.Iterators; |
| |
| import java.io.IOException; |
| import java.util.List; |
| |
| import org.eclipse.emf.compare.Comparison; |
| import org.eclipse.emf.compare.Diff; |
| import org.eclipse.emf.compare.DifferenceKind; |
| import org.eclipse.emf.compare.uml2.internal.IntervalConstraintChange; |
| import org.eclipse.emf.compare.uml2.tests.AbstractUMLInputData; |
| import org.eclipse.emf.compare.uml2.tests.AbstractUMLTest; |
| import org.eclipse.emf.compare.uml2.tests.timeConstraint.data.TimeConstraintInputData; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.junit.AfterClass; |
| import org.junit.BeforeClass; |
| import org.junit.Test; |
| |
| @SuppressWarnings("nls") |
| public class AddTimeConstraintTest extends AbstractUMLTest { |
| |
| private TimeConstraintInputData input = new TimeConstraintInputData(); |
| |
| @BeforeClass |
| public static void setupClass() { |
| fillRegistries(); |
| } |
| |
| @AfterClass |
| public static void teardownClass() { |
| resetRegistries(); |
| } |
| |
| @Test |
| public void testA10UseCase() throws IOException { |
| final Resource left = input.getA1Left(); |
| final Resource right = input.getA1Right(); |
| |
| final Comparison comparison = compare(left, right); |
| testAB1(TestKind.ADD, comparison); |
| |
| testMergeLeftToRight(left, right, null); |
| testMergeRightToLeft(left, right, null); |
| } |
| |
| @Test |
| public void testA11UseCase() throws IOException { |
| final Resource left = input.getA1Left(); |
| final Resource right = input.getA1Right(); |
| |
| final Comparison comparison = compare(right, left); |
| testAB1(TestKind.DELETE, comparison); |
| |
| testMergeLeftToRight(right, left, null); |
| testMergeRightToLeft(right, left, null); |
| } |
| |
| @Test |
| public void testA10UseCase3way() throws IOException { |
| final Resource left = input.getA1Left(); |
| final Resource right = input.getA1Right(); |
| |
| final Comparison comparison = compare(left, right, right); |
| testAB1(TestKind.ADD, comparison); |
| |
| testMergeLeftToRight(left, right, right); |
| testMergeRightToLeft(left, right, right); |
| } |
| |
| @Test |
| public void testA11UseCase3way() throws IOException { |
| final Resource left = input.getA1Left(); |
| final Resource right = input.getA1Right(); |
| |
| final Comparison comparison = compare(left, right, left); |
| testAB1(TestKind.DELETE, comparison); |
| |
| testMergeLeftToRight(left, right, left); |
| testMergeRightToLeft(left, right, left); |
| } |
| |
| private void testAB1(TestKind kind, final Comparison comparison) { |
| final List<Diff> differences = comparison.getDifferences(); |
| |
| // We should have no less and no more than 10 differences |
| assertEquals(10, differences.size()); |
| |
| Predicate<? super Diff> addTimeConstraintDescription = null; |
| Predicate<? super Diff> addTimeIntervalDescription = null; |
| Predicate<? super Diff> addTimeExpressionMinDescription = null; |
| Predicate<? super Diff> addTimeExpressionMaxDescription = null; |
| Predicate<? super Diff> addMinValueDescription = null; |
| Predicate<? super Diff> addMaxValueDescription = null; |
| Predicate<? super Diff> addConstrainedElementInTimeConstraintDescription = null; |
| Predicate<? super Diff> addMinInTimeIntervalDescription = null; |
| Predicate<? super Diff> addMaxInTimeIntervalDescription = null; |
| |
| if (kind.equals(TestKind.DELETE)) { |
| addTimeConstraintDescription = removed("model.interaction0.TimeConstraint0"); //$NON-NLS-1$ |
| addTimeIntervalDescription = removed("model.interaction0.TimeConstraint0.TimeInterval"); //$NON-NLS-1$ |
| addTimeExpressionMinDescription = removed("model.TimeIntervalMin0"); //$NON-NLS-1$ |
| addTimeExpressionMaxDescription = removed("model.TimeIntervalMax0"); |
| addMinValueDescription = removed("model.TimeIntervalMin0.min"); //$NON-NLS-1$ |
| addMaxValueDescription = removed("model.TimeIntervalMax0.max"); //$NON-NLS-1$ |
| addConstrainedElementInTimeConstraintDescription = removedFromReference( |
| "model.interaction0.TimeConstraint0", "constrainedElement", |
| "model.interaction0.Message0Send0"); |
| addMinInTimeIntervalDescription = changedReference( |
| "model.interaction0.TimeConstraint0.TimeInterval", "min", "model.TimeIntervalMin0", null); |
| addMaxInTimeIntervalDescription = changedReference( |
| "model.interaction0.TimeConstraint0.TimeInterval", "max", "model.TimeIntervalMax0", null); |
| } else { |
| addTimeConstraintDescription = added("model.interaction0.TimeConstraint0"); //$NON-NLS-1$ |
| addTimeIntervalDescription = added("model.interaction0.TimeConstraint0.TimeInterval"); //$NON-NLS-1$ |
| addTimeExpressionMinDescription = added("model.TimeIntervalMin0"); //$NON-NLS-1$ |
| addTimeExpressionMaxDescription = added("model.TimeIntervalMax0"); |
| addMinValueDescription = added("model.TimeIntervalMin0.min"); //$NON-NLS-1$ |
| addMaxValueDescription = added("model.TimeIntervalMax0.max"); //$NON-NLS-1$ |
| addConstrainedElementInTimeConstraintDescription = addedToReference( |
| "model.interaction0.TimeConstraint0", "constrainedElement", |
| "model.interaction0.Message0Send0"); |
| addMinInTimeIntervalDescription = changedReference( |
| "model.interaction0.TimeConstraint0.TimeInterval", "min", null, "model.TimeIntervalMin0"); |
| addMaxInTimeIntervalDescription = changedReference( |
| "model.interaction0.TimeConstraint0.TimeInterval", "max", null, "model.TimeIntervalMax0"); |
| } |
| |
| final Diff addTimeConstraint = Iterators.find(differences.iterator(), addTimeConstraintDescription); |
| final Diff addTimeInterval = Iterators.find(differences.iterator(), addTimeIntervalDescription); |
| final Diff addTimeExpressionMin = Iterators.find(differences.iterator(), |
| addTimeExpressionMinDescription); |
| final Diff addTimeExpressionMax = Iterators.find(differences.iterator(), |
| addTimeExpressionMaxDescription); |
| final Diff addMinValue = Iterators.find(differences.iterator(), addMinValueDescription); |
| final Diff addMaxValue = Iterators.find(differences.iterator(), addMaxValueDescription); |
| final Diff addConstrainedElementInTimeConstraint = Iterators.find(differences.iterator(), |
| addConstrainedElementInTimeConstraintDescription); |
| final Diff addMinInTimeInterval = Iterators.find(differences.iterator(), |
| addMinInTimeIntervalDescription); |
| final Diff addMaxInTimeInterval = Iterators.find(differences.iterator(), |
| addMaxInTimeIntervalDescription); |
| |
| assertNotNull(addTimeConstraint); |
| assertNotNull(addTimeInterval); |
| assertNotNull(addTimeExpressionMin); |
| assertNotNull(addTimeExpressionMax); |
| assertNotNull(addMinValue); |
| assertNotNull(addMaxValue); |
| assertNotNull(addConstrainedElementInTimeConstraint); |
| assertNotNull(addMinInTimeInterval); |
| assertNotNull(addMaxInTimeInterval); |
| |
| // CHECK EXTENSION |
| assertEquals(1, count(differences, instanceOf(IntervalConstraintChange.class))); |
| Diff addUMLMessage = null; |
| if (kind.equals(TestKind.ADD)) { |
| addUMLMessage = Iterators.find(differences.iterator(), |
| and(instanceOf(IntervalConstraintChange.class), ofKind(DifferenceKind.ADD))); |
| } else { |
| addUMLMessage = Iterators.find(differences.iterator(), |
| and(instanceOf(IntervalConstraintChange.class), ofKind(DifferenceKind.DELETE))); |
| } |
| assertNotNull(addUMLMessage); |
| assertEquals(9, addUMLMessage.getRefinedBy().size()); |
| assertTrue(addUMLMessage.getRefinedBy().contains(addConstrainedElementInTimeConstraint)); |
| assertTrue(addUMLMessage.getRefinedBy().contains(addTimeInterval)); |
| assertTrue(addUMLMessage.getRefinedBy().contains(addMinInTimeInterval)); |
| assertTrue(addUMLMessage.getRefinedBy().contains(addMaxInTimeInterval)); |
| assertTrue(addUMLMessage.getRefinedBy().contains(addMinValue)); |
| assertTrue(addUMLMessage.getRefinedBy().contains(addMaxValue)); |
| assertTrue(addUMLMessage.getRefinedBy().contains(addTimeExpressionMin)); |
| assertTrue(addUMLMessage.getRefinedBy().contains(addTimeExpressionMax)); |
| assertTrue(addUMLMessage.getRefinedBy().contains(addTimeConstraint)); |
| |
| // CHECK REQUIREMENT |
| if (kind.equals(TestKind.ADD)) { |
| |
| assertEquals(0, addTimeConstraint.getRequires().size()); |
| |
| assertEquals(1, addTimeInterval.getRequires().size()); |
| assertTrue(addTimeInterval.getRequires().contains(addTimeConstraint)); |
| |
| assertEquals(0, addTimeExpressionMin.getRequires().size()); |
| assertEquals(0, addTimeExpressionMax.getRequires().size()); |
| |
| assertEquals(1, addMinValue.getRequires().size()); |
| assertTrue(addMinValue.getRequires().contains(addTimeExpressionMin)); |
| |
| assertEquals(1, addMaxValue.getRequires().size()); |
| assertTrue(addMaxValue.getRequires().contains(addTimeExpressionMax)); |
| |
| assertEquals(1, addConstrainedElementInTimeConstraint.getRequires().size()); |
| assertTrue(addTimeInterval.getRequires().contains(addTimeConstraint)); |
| |
| assertEquals(2, addMinInTimeInterval.getRequires().size()); |
| assertTrue(addMinInTimeInterval.getRequires().contains(addTimeInterval)); |
| assertTrue(addMinInTimeInterval.getRequires().contains(addTimeExpressionMin)); |
| |
| assertEquals(2, addMaxInTimeInterval.getRequires().size()); |
| assertTrue(addMaxInTimeInterval.getRequires().contains(addTimeInterval)); |
| assertTrue(addMaxInTimeInterval.getRequires().contains(addTimeExpressionMax)); |
| |
| } else { |
| assertEquals(2, addTimeConstraint.getRequires().size()); |
| assertTrue(addTimeConstraint.getRequires().contains(addConstrainedElementInTimeConstraint)); |
| assertTrue(addTimeConstraint.getRequires().contains(addTimeInterval)); |
| |
| assertEquals(2, addTimeInterval.getRequires().size()); |
| assertTrue(addTimeInterval.getRequires().contains(addMinInTimeInterval)); |
| assertTrue(addTimeInterval.getRequires().contains(addMaxInTimeInterval)); |
| |
| assertEquals(2, addTimeExpressionMin.getRequires().size()); |
| assertTrue(addTimeExpressionMin.getRequires().contains(addMinValue)); |
| assertTrue(addTimeExpressionMin.getRequires().contains(addMinInTimeInterval)); |
| |
| assertEquals(2, addTimeExpressionMax.getRequires().size()); |
| assertTrue(addTimeExpressionMax.getRequires().contains(addMaxValue)); |
| assertTrue(addTimeExpressionMax.getRequires().contains(addMaxInTimeInterval)); |
| |
| assertEquals(0, addMinValue.getRequires().size()); |
| |
| assertEquals(0, addMaxValue.getRequires().size()); |
| |
| assertEquals(0, addConstrainedElementInTimeConstraint.getRequires().size()); |
| |
| assertEquals(0, addMinInTimeInterval.getRequires().size()); |
| |
| assertEquals(0, addMaxInTimeInterval.getRequires().size()); |
| } |
| |
| // CHECK EQUIVALENCE |
| assertEquals(0, comparison.getEquivalences().size()); |
| |
| testIntersections(comparison); |
| |
| } |
| |
| @Override |
| protected AbstractUMLInputData getInput() { |
| return input; |
| } |
| |
| } |
