AddAssociation3Test.java

/*******************************************************************************
 * Copyright (c) 2012, 2016 Obeo and others.
 * 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.association;

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.onEObject;
import static org.eclipse.emf.compare.utils.EMFComparePredicates.onFeature;
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 java.util.regex.Pattern;

import org.eclipse.emf.compare.Comparison;
import org.eclipse.emf.compare.Diff;
import org.eclipse.emf.compare.DifferenceKind;
import org.eclipse.emf.compare.postprocessor.IPostProcessor.Descriptor.Registry;
import org.eclipse.emf.compare.tests.postprocess.data.TestPostProcessor;
import org.eclipse.emf.compare.uml2.internal.AssociationChange;
import org.eclipse.emf.compare.uml2.internal.MultiplicityElementChange;
import org.eclipse.emf.compare.uml2.internal.postprocessor.MultiplicityElementChangePostProcessor;
import org.eclipse.emf.compare.uml2.tests.AbstractUMLInputData;
import org.eclipse.emf.compare.uml2.tests.AbstractUMLTest;
import org.eclipse.emf.compare.uml2.tests.association.data.AssociationInputData;
import org.eclipse.emf.ecore.resource.Resource;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;

@SuppressWarnings("nls")
public class AddAssociation3Test extends AbstractUMLTest {

	private AssociationInputData input = new AssociationInputData();

	@BeforeClass
	public static void setupClass() {
		fillRegistries();
	}

	@AfterClass
	public static void teardownClass() {
		resetRegistries();
	}

	@Test
	public void testA40UseCase() throws IOException {
		final Resource left = input.getA4Left();
		final Resource right = input.getA4Right();

		final Comparison comparison = compare(left, right);
		testAB1(TestKind.ADD, comparison);
	}

	@Test
	public void testMergeRtLA40UseCase() throws IOException {
		final Resource left = input.getA4Left();
		final Resource right = input.getA4Left();

		testMergeRightToLeft(left, right, null);
	}

	@Test
	public void testMergeLtRA40UseCase() throws IOException {
		final Resource left = input.getA4Left();
		final Resource right = input.getA4Left();

		testMergeLeftToRight(left, right, null);
	}

	@Test
	public void testA41UseCase() throws IOException {
		final Resource left = input.getA4Left();
		final Resource right = input.getA4Right();

		final Comparison comparison = compare(right, left);
		testAB1(TestKind.DELETE, comparison);
	}

	@Test
	public void testMergeRtLA41UseCase() throws IOException {
		final Resource left = input.getA4Left();
		final Resource right = input.getA4Left();

		testMergeRightToLeft(right, left, null);
	}

	@Test
	public void testMergeLtRA41UseCase() throws IOException {
		final Resource left = input.getA4Left();
		final Resource right = input.getA4Left();

		testMergeLeftToRight(right, left, null);
	}

	@Test
	public void testA40UseCase3way() throws IOException {
		final Resource left = input.getA4Left();
		final Resource right = input.getA4Right();

		final Comparison comparison = compare(left, right, right);
		testAB1(TestKind.ADD, comparison);
	}

	@Test
	public void testMergeRtLA40UseCase3way() throws IOException {
		final Resource left = input.getA4Left();
		final Resource right = input.getA4Left();

		testMergeRightToLeft(left, right, right);
	}

	@Test
	public void testMergeLtRA40UseCase3way() throws IOException {
		final Resource left = input.getA4Left();
		final Resource right = input.getA4Left();

		testMergeLeftToRight(left, right, right);
	}

	@Test
	public void testA41UseCase3way() throws IOException {
		final Resource left = input.getA4Left();
		final Resource right = input.getA4Right();

		final Comparison comparison = compare(left, right, left);
		testAB1(TestKind.DELETE, comparison);
	}

	@Test
	public void testMergeRtLA41UseCase3way() throws IOException {
		final Resource left = input.getA4Left();
		final Resource right = input.getA4Left();

		testMergeRightToLeft(left, right, left);
	}

	@Test
	public void testMergeLtRA41UseCase3way() throws IOException {
		final Resource left = input.getA4Left();
		final Resource right = input.getA4Left();

		testMergeLeftToRight(left, right, left);
	}

	private void testAB1(TestKind kind, final Comparison comparison) {
		final List<Diff> differences = comparison.getDifferences();

		assertEquals(18, differences.size());

		Predicate<? super Diff> addAssociationDescription = null;
		Predicate<? super Diff> addPropertyClass1Description = null;
		Predicate<? super Diff> addPropertyClass0Description = null;
		Predicate<? super Diff> addPropertyClass1InAssociationDescription = null;
		Predicate<? super Diff> addPropertyClass0InAssociationDescription = null;
		Predicate<? super Diff> addRefAssociationInPropertyClass1Description = null;
		Predicate<? super Diff> addRefTypeInPropertyClass1Description = null;
		Predicate<? super Diff> addRefAssociationInPropertyClass0Description = null;
		Predicate<? super Diff> addRefTypeInPropertyClass0Description = null;
		Predicate<? super Diff> addLiteralIntegerInClass1Description = null;
		Predicate<? super Diff> addUnlimitedNaturalInClass1Description = null;
		Predicate<? super Diff> addLiteralIntegerInClass0Description = null;
		Predicate<? super Diff> addUnlimitedNaturalInClass0Description = null;

		if (kind.equals(TestKind.DELETE)) {
			addAssociationDescription = removed("model.AssociationClass0"); //$NON-NLS-1$
			addPropertyClass1Description = removedFromReference("model.Class0", "ownedAttribute",
					"model.Class0.class1");
			addPropertyClass0Description = removedFromReference("model.AssociationClass0", "ownedEnd",
					"model.AssociationClass0.class0");
			addPropertyClass1InAssociationDescription = removedFromReference("model.AssociationClass0",
					"memberEnd", "model.Class0.class1");
			addPropertyClass0InAssociationDescription = removedFromReference("model.AssociationClass0",
					"memberEnd", "model.AssociationClass0.class0");
			addRefAssociationInPropertyClass1Description = changedReference("model.Class0.class1",
					"association", "model.AssociationClass0", null);
			addRefTypeInPropertyClass1Description = changedReference("model.Class0.class1", "type",
					"model.Class1", null);
			addRefAssociationInPropertyClass0Description = changedReference("model.AssociationClass0.class0",
					"association", "model.AssociationClass0", null);
			addRefTypeInPropertyClass0Description = changedReference("model.AssociationClass0.class0", "type",
					"model.Class0", null);
			addLiteralIntegerInClass1Description = removedLowerValueIn("model.Class0.class1");
			addUnlimitedNaturalInClass1Description = removedUpperValueIn("model.Class0.class1");
			addLiteralIntegerInClass0Description = removedLowerValueIn("model.AssociationClass0.class0");
			addUnlimitedNaturalInClass0Description = removedUpperValueIn("model.AssociationClass0.class0");
		} else {
			addAssociationDescription = added("model.AssociationClass0"); //$NON-NLS-1$
			addPropertyClass1Description = addedToReference("model.Class0", "ownedAttribute",
					"model.Class0.class1");
			addPropertyClass0Description = addedToReference("model.AssociationClass0", "ownedEnd",
					"model.AssociationClass0.class0");
			addPropertyClass1InAssociationDescription = addedToReference("model.AssociationClass0",
					"memberEnd", "model.Class0.class1");
			addPropertyClass0InAssociationDescription = addedToReference("model.AssociationClass0",
					"memberEnd", "model.AssociationClass0.class0");
			addRefAssociationInPropertyClass1Description = changedReference("model.Class0.class1",
					"association", null, "model.AssociationClass0");
			addRefTypeInPropertyClass1Description = changedReference("model.Class0.class1", "type", null,
					"model.Class1");
			addRefAssociationInPropertyClass0Description = changedReference("model.AssociationClass0.class0",
					"association", null, "model.AssociationClass0");
			addRefTypeInPropertyClass0Description = changedReference("model.AssociationClass0.class0", "type",
					null, "model.Class0");
			addLiteralIntegerInClass1Description = addedLowerValueIn("model.Class0.class1");
			addUnlimitedNaturalInClass1Description = addedUpperValueIn("model.Class0.class1");
			addLiteralIntegerInClass0Description = addedLowerValueIn("model.AssociationClass0.class0");
			addUnlimitedNaturalInClass0Description = addedUpperValueIn("model.AssociationClass0.class0");
		}

		final Diff addAssociation = Iterators.find(differences.iterator(), addAssociationDescription);
		final Diff addPropertyClass1 = Iterators.find(differences.iterator(), addPropertyClass1Description);
		final Diff addPropertyClass0 = Iterators.find(differences.iterator(), addPropertyClass0Description);
		final Diff addPropertyClass1InAssociation = Iterators.find(differences.iterator(),
				addPropertyClass1InAssociationDescription);
		final Diff addPropertyClass0InAssociation = Iterators.find(differences.iterator(),
				addPropertyClass0InAssociationDescription);
		final Diff addRefAssociationInPropertyClass1 = Iterators.find(differences.iterator(),
				addRefAssociationInPropertyClass1Description);
		final Diff addRefTypeInPropertyClass1 = Iterators.find(differences.iterator(),
				addRefTypeInPropertyClass1Description);
		final Diff addRefAssociationInPropertyClass0 = Iterators.find(differences.iterator(),
				addRefAssociationInPropertyClass0Description);
		final Diff addRefTypeInPropertyClass0 = Iterators.find(differences.iterator(),
				addRefTypeInPropertyClass0Description);
		final Diff addLiteralIntegerInClass1 = Iterators.find(differences.iterator(),
				addLiteralIntegerInClass1Description);
		final Diff addUnlimitedNaturalInClass1 = Iterators.find(differences.iterator(),
				addUnlimitedNaturalInClass1Description);
		final Diff addLiteralIntegerInClass0 = Iterators.find(differences.iterator(),
				addLiteralIntegerInClass0Description);
		final Diff addUnlimitedNaturalInClass0 = Iterators.find(differences.iterator(),
				addUnlimitedNaturalInClass0Description);
		// duplicate diff: Association.memberEnd to class0

		assertNotNull(addAssociation);
		assertNotNull(addPropertyClass1);
		assertNotNull(addPropertyClass0);
		assertNotNull(addPropertyClass1InAssociation);
		assertNotNull(addRefAssociationInPropertyClass1);
		assertNotNull(addRefTypeInPropertyClass1);
		assertNotNull(addRefAssociationInPropertyClass0);
		assertNotNull(addRefTypeInPropertyClass0);
		assertNotNull(addLiteralIntegerInClass1);
		assertNotNull(addUnlimitedNaturalInClass1);
		assertNotNull(addLiteralIntegerInClass0);
		assertNotNull(addUnlimitedNaturalInClass0);
		assertNotNull(addPropertyClass0InAssociation);

		// CHECK EXTENSION
		assertEquals(1, count(differences, instanceOf(AssociationChange.class)));
		Diff addUMLAssociation = null;
		if (kind.equals(TestKind.ADD)) {
			addUMLAssociation = Iterators.find(differences.iterator(),
					and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.ADD)));
		} else {
			addUMLAssociation = Iterators.find(differences.iterator(),
					and(instanceOf(AssociationChange.class), ofKind(DifferenceKind.DELETE)));
		}
		assertNotNull(addUMLAssociation);
		assertEquals(13, addUMLAssociation.getRefinedBy().size());
		assertTrue(addUMLAssociation.getRefinedBy().contains(addRefTypeInPropertyClass1));
		assertTrue(addUMLAssociation.getRefinedBy().contains(addRefAssociationInPropertyClass1));
		assertTrue(addUMLAssociation.getRefinedBy().contains(addRefTypeInPropertyClass0));
		assertTrue(addUMLAssociation.getRefinedBy().contains(addRefAssociationInPropertyClass0));
		assertTrue(addUMLAssociation.getRefinedBy().contains(addAssociation));
		assertTrue(addUMLAssociation.getRefinedBy().contains(addPropertyClass0));
		assertTrue(addUMLAssociation.getRefinedBy().contains(addPropertyClass1));
		assertTrue(addUMLAssociation.getRefinedBy().contains(addPropertyClass1InAssociation));
		assertTrue(addUMLAssociation.getRefinedBy().contains(addPropertyClass0InAssociation));

		// MultiplicityElementChanges
		assertTrue(addUMLAssociation.getRefinedBy()
				.contains(Iterators.find(addLiteralIntegerInClass1.getRefines().iterator(),
						instanceOf(MultiplicityElementChange.class))));
		assertTrue(addUMLAssociation.getRefinedBy()
				.contains(Iterators.find(addUnlimitedNaturalInClass1.getRefines().iterator(),
						instanceOf(MultiplicityElementChange.class))));
		assertTrue(addUMLAssociation.getRefinedBy()
				.contains(Iterators.find(addLiteralIntegerInClass0.getRefines().iterator(),
						instanceOf(MultiplicityElementChange.class))));
		assertTrue(addUMLAssociation.getRefinedBy()
				.contains(Iterators.find(addUnlimitedNaturalInClass0.getRefines().iterator(),
						instanceOf(MultiplicityElementChange.class))));

		// CHECK REQUIREMENT
		if (kind.equals(TestKind.ADD)) {
			assertEquals(1, addPropertyClass0.getRequires().size());
			assertTrue(addPropertyClass0.getRequires().contains(addAssociation));

			assertEquals(0, addPropertyClass1.getRequires().size());

			assertEquals(2, addPropertyClass1InAssociation.getRequires().size());
			assertTrue(addPropertyClass1InAssociation.getRequires().contains(addPropertyClass1));
			assertTrue(addPropertyClass1InAssociation.getRequires().contains(addAssociation));

			assertEquals(2, addRefAssociationInPropertyClass1.getRequires().size());
			assertTrue(addRefAssociationInPropertyClass1.getRequires().contains(addPropertyClass1));
			assertTrue(addRefAssociationInPropertyClass1.getRequires().contains(addAssociation));

			assertEquals(1, addRefTypeInPropertyClass1.getRequires().size());
			assertTrue(addRefTypeInPropertyClass1.getRequires().contains(addPropertyClass1));

			assertEquals(2, addRefAssociationInPropertyClass0.getRequires().size());
			assertTrue(addRefAssociationInPropertyClass0.getRequires().contains(addPropertyClass0));
			assertTrue(addRefAssociationInPropertyClass0.getRequires().contains(addAssociation));

			assertEquals(1, addRefTypeInPropertyClass0.getRequires().size());
			assertTrue(addRefTypeInPropertyClass0.getRequires().contains(addPropertyClass0));

			assertEquals(0, addAssociation.getRequires().size());
			assertEquals(0, addUMLAssociation.getRequires().size());

			assertEquals(1, addLiteralIntegerInClass1.getRequires().size());
			assertTrue(addLiteralIntegerInClass1.getRequires().contains(addPropertyClass1));

			assertEquals(1, addUnlimitedNaturalInClass1.getRequires().size());
			assertTrue(addUnlimitedNaturalInClass1.getRequires().contains(addPropertyClass1));

			assertEquals(1, addLiteralIntegerInClass0.getRequires().size());
			assertTrue(addLiteralIntegerInClass0.getRequires().contains(addPropertyClass0));

			assertEquals(1, addUnlimitedNaturalInClass0.getRequires().size());
			assertTrue(addUnlimitedNaturalInClass0.getRequires().contains(addPropertyClass0));
		} else {
			assertEquals(5, addPropertyClass1.getRequires().size());
			assertTrue(addPropertyClass1.getRequires().contains(addLiteralIntegerInClass1));
			assertTrue(addPropertyClass1.getRequires().contains(addUnlimitedNaturalInClass1));
			assertTrue(addPropertyClass1.getRequires().contains(addRefAssociationInPropertyClass1));
			assertTrue(addPropertyClass1.getRequires().contains(addRefTypeInPropertyClass1));
			assertTrue(addPropertyClass1.getRequires().contains(addPropertyClass1InAssociation));

			assertEquals(5, addPropertyClass0.getRequires().size());
			assertTrue(addPropertyClass0.getRequires().contains(addLiteralIntegerInClass0));
			assertTrue(addPropertyClass0.getRequires().contains(addUnlimitedNaturalInClass0));
			assertTrue(addPropertyClass0.getRequires().contains(addRefAssociationInPropertyClass0));
			assertTrue(addPropertyClass0.getRequires().contains(addRefTypeInPropertyClass0));
			assertTrue(addPropertyClass0.getRequires().contains(addPropertyClass0InAssociation));

			assertEquals(0, addRefAssociationInPropertyClass1.getRequires().size());
			assertEquals(0, addRefTypeInPropertyClass1.getRequires().size());
			assertEquals(0, addRefAssociationInPropertyClass0.getRequires().size());
			assertEquals(0, addRefTypeInPropertyClass0.getRequires().size());

			assertEquals(5, addAssociation.getRequires().size());
			assertTrue(addAssociation.getRequires().contains(addPropertyClass0));
			assertTrue(addAssociation.getRequires().contains(addRefAssociationInPropertyClass1));
			assertTrue(addAssociation.getRequires().contains(addRefAssociationInPropertyClass0));
			assertTrue(addAssociation.getRequires().contains(addPropertyClass1InAssociation));
			assertTrue(addAssociation.getRequires().contains(addPropertyClass0InAssociation));

			assertEquals(0, addUMLAssociation.getRequires().size());
			assertEquals(0, addLiteralIntegerInClass1.getRequires().size());
			assertEquals(0, addUnlimitedNaturalInClass1.getRequires().size());
			assertEquals(0, addLiteralIntegerInClass0.getRequires().size());
			assertEquals(0, addUnlimitedNaturalInClass0.getRequires().size());
		}

		assertNotNull(addPropertyClass1InAssociation.getEquivalence());
		assertTrue(addPropertyClass1InAssociation.getEquivalence().getDifferences()
				.contains(addRefAssociationInPropertyClass1));

		testIntersections(comparison);
	}

	private static Predicate<? super Diff> addedLowerValueIn(final String qualifiedName) {
		return and(ofKind(DifferenceKind.ADD), onEObject(qualifiedName), onFeature("lowerValue"));
	}

	private static Predicate<? super Diff> addedUpperValueIn(final String qualifiedName) {
		return and(ofKind(DifferenceKind.ADD), onEObject(qualifiedName), onFeature("upperValue"));
	}

	private static Predicate<? super Diff> removedLowerValueIn(final String qualifiedName) {
		return and(ofKind(DifferenceKind.DELETE), onEObject(qualifiedName), onFeature("lowerValue"));
	}

	private static Predicate<? super Diff> removedUpperValueIn(final String qualifiedName) {
		return and(ofKind(DifferenceKind.DELETE), onEObject(qualifiedName), onFeature("upperValue"));
	}

	@Override
	protected AbstractUMLInputData getInput() {
		return input;
	}

	@Override
	protected void registerPostProcessors(Registry<String> postProcessorRegistry) {
		super.registerPostProcessors(postProcessorRegistry);
		postProcessorRegistry.put(MultiplicityElementChangePostProcessor.class.getName(),
				new TestPostProcessor.TestPostProcessorDescriptor(
						Pattern.compile("http://www.eclipse.org/uml2/\\d\\.0\\.0/UML"), null,
						new MultiplicityElementChangePostProcessor(), 25));
	}
}