/*****************************************************************************
 * Copyright (c) 2016 EclipseSource Services GmbH
 *
 * 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:
 *     Philip Langer - initial API and implementation
 *****************************************************************************/
package org.eclipse.papyrusrt.umlrt.tooling.compare.internal;

import static com.google.common.base.Predicates.instanceOf;
import static com.google.common.collect.Iterables.all;
import static com.google.common.collect.Iterables.contains;
import static com.google.common.collect.Iterables.filter;
import static com.google.common.collect.Iterables.get;
import static com.google.common.collect.Iterables.size;
import static com.google.common.collect.Iterables.transform;
import static com.google.common.collect.Iterables.tryFind;
import static org.eclipse.emf.compare.DifferenceKind.ADD;
import static org.eclipse.emf.compare.DifferenceKind.CHANGE;
import static org.eclipse.emf.compare.DifferenceKind.DELETE;
import static org.eclipse.emf.compare.DifferenceKind.MOVE;
import static org.eclipse.emf.compare.DifferenceSource.LEFT;
import static org.eclipse.emf.compare.DifferenceSource.RIGHT;
import static org.eclipse.emf.compare.utils.EMFComparePredicates.fromSide;
import static org.eclipse.emf.compare.utils.EMFComparePredicates.ofKind;
import static org.eclipse.emf.compare.utils.EMFComparePredicates.onFeature;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;

import java.io.IOException;
import java.util.List;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.compare.AttributeChange;
import org.eclipse.emf.compare.Comparison;
import org.eclipse.emf.compare.Conflict;
import org.eclipse.emf.compare.ConflictKind;
import org.eclipse.emf.compare.Diff;
import org.eclipse.emf.compare.ReferenceChange;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.papyrusrt.umlrt.tooling.compare.umlrt.internal.ProtocolChange;
import org.eclipse.uml2.uml.Collaboration;
import org.eclipse.uml2.uml.UMLPackage;
import org.junit.Test;

import com.google.common.base.Function;
import com.google.common.base.Optional;
import com.google.common.base.Predicate;
import com.google.common.collect.Lists;

/**
 * Integration test for {@link ProtocolChange protocol changes}.
 * 
 * <p>
 * Tests the entire comparison process with the {@link UMLRTPostProcessor} and
 * asserts the detection of {@link ProtocolChange protocol changes} of different
 * kinds, such as the single and multiple additions, deletions, and moves, each
 * in two-way and three-way comparisons on both sides.
 * </p>
 * <p>
 * In the test scenario <em>single-1</em>, the protocol change in question is
 * always performed in the model called <code>right.uml</code>.
 * </p>
 * <p>
 * In the test scenario <em>multiple-1</em>, the protocols <em>Resource</em> and
 * <em>USBProtocol</em> have been moved on the right-hand side (
 * <code>right.uml</code>). On the left-hand side (<code>left.uml</code>), the
 * protocol <em>AppControl</em> has been deleted, and <em>TestProtocol</em> has
 * been added.
 * </p>
 * 
 * @author Philip Langer <planger@eclipsesource.com>
 */
@SuppressWarnings("restriction")
public class UMLRTProtocolChangeTest extends AbstractUMLRTTest {

	private static Function<EObject, String> COLLABORATION_NAME = new Function<EObject, String>() {
		@Override
		public String apply(EObject input) {
			if (input instanceof Collaboration) {
				return ((Collaboration) input).getName();
			}
			return null;
		}
	};

	private static Function<ProtocolChange, String> PROTOCOL_CHANGE_COLLABORATION_NAME = new Function<ProtocolChange, String>() {
		@Override
		public String apply(ProtocolChange input) {
			if (input != null && input.getDiscriminant() instanceof Collaboration) {
				return COLLABORATION_NAME.apply(input.getDiscriminant());
			}
			return null;
		}
	};

	private static final Predicate<ProtocolChange> PROTOCOL_CHANGE_WITH_COLLABORATION_NAME_PREDICATE(
			final String protocolName) {
		return new Predicate<ProtocolChange>() {
			@Override
			public boolean apply(ProtocolChange input) {
				String name = PROTOCOL_CHANGE_COLLABORATION_NAME.apply(input);
				return name != null && name.equals(protocolName);
			}
		};
	}

	private static final String ADDED_PROTOCOL_NAME_MULTIPLE_1 = "TestProtocol"; //$NON-NLS-1$
	private static final String DELETED_PROTOCOL_NAME_MULTIPLE_1 = "AppControl"; //$NON-NLS-1$
	private static final String PROTOCOL_NAME_SINGLE_1 = "Resource"; //$NON-NLS-1$
	private static final String MOVED_PROTOCOL_MULTIPLE_1_1 = "Resource"; //$NON-NLS-1$
	private static final String MOVED_PROTOCOL_MULTIPLE_1_2 = "USBProtocol"; //$NON-NLS-1$
	private static final String RENAMED_PROTOCOL_NAME_MULTIPLE_1 = "Resource1"; //$NON-NLS-1$
	private static final String CHANGED_PROTOCOL_NAME_MULTIPLE_3_1 = "Resource"; //$NON-NLS-1$
	private static final String RENAMED_PROTOCOL_MULTIPLE_3_1 = "Resource1"; //$NON-NLS-1$
	private static final String CHANGED_PROTOCOL_NAME_MULTIPLE_3_2 = "USBProtocol"; //$NON-NLS-1$
	private static final String RENAMED_PROTOCOL_MULTIPLE_3_2 = "USBProtocol1"; //$NON-NLS-1$

	private UMLRTProtocolChangeTestData input = new UMLRTProtocolChangeTestData();

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

	@Test
	public void testSingleProtocolAddInTwoWay() throws IOException {
		final Resource left = input.getAddDeleteSingle1Left();
		final Resource right = input.getAddDeleteSingle1Right();
		final Comparison comparison = compare(left, right);
		final ProtocolChange protocolChange = getAndAssertSingle1ProtocolChange(comparison);
		assertEquals(ADD, protocolChange.getKind());
		assertEquals(LEFT, protocolChange.getSource());
	}

	@Test
	public void testSingleProtocolDeleteInTwoWay() throws IOException {
		final Resource left = input.getAddDeleteSingle1Left();
		final Resource right = input.getAddDeleteSingle1Right();
		final Comparison comparison = compare(right, left);
		final ProtocolChange protocolChange = getAndAssertSingle1ProtocolChange(comparison);
		assertEquals(DELETE, protocolChange.getKind());
		assertEquals(LEFT, protocolChange.getSource());
	}

	@Test
	public void testSingleProtocolAddInThreeWayLeft() throws IOException {
		final Resource left = input.getAddDeleteSingle1Left();
		final Resource right = input.getAddDeleteSingle1Right();
		final Resource origin = right;
		final Comparison comparison = compare(left, right, origin);
		final ProtocolChange protocolChange = getAndAssertSingle1ProtocolChange(comparison);
		assertEquals(ADD, protocolChange.getKind());
		assertEquals(LEFT, protocolChange.getSource());
	}

	@Test
	public void testSingleProtocolAddInThreeWayRight() throws IOException {
		final Resource left = input.getAddDeleteSingle1Left();
		final Resource right = input.getAddDeleteSingle1Right();
		final Resource origin = right;
		final Comparison comparison = compare(right, left, origin);
		final ProtocolChange protocolChange = getAndAssertSingle1ProtocolChange(comparison);
		assertEquals(ADD, protocolChange.getKind());
		assertEquals(RIGHT, protocolChange.getSource());
	}

	@Test
	public void testSingleProtocolDeleteInThreeWayLeft() throws IOException {
		final Resource left = input.getAddDeleteSingle1Left();
		final Resource right = input.getAddDeleteSingle1Right();
		final Resource origin = left;
		final Comparison comparison = compare(right, left, origin);
		final ProtocolChange protocolChange = getAndAssertSingle1ProtocolChange(comparison);
		assertEquals(DELETE, protocolChange.getKind());
		assertEquals(LEFT, protocolChange.getSource());
	}

	@Test
	public void testSingleProtocolDeleteInThreeWayRight() throws IOException {
		final Resource left = input.getAddDeleteSingle1Left();
		final Resource right = input.getAddDeleteSingle1Right();
		final Resource origin = left;
		final Comparison comparison = compare(left, right, origin);
		final ProtocolChange protocolChange = getAndAssertSingle1ProtocolChange(comparison);
		assertEquals(DELETE, protocolChange.getKind());
		assertEquals(RIGHT, protocolChange.getSource());
	}

	@Test
	public void testSingleProtocolMoveInTwoWay() throws IOException {
		final Resource left = input.getMoveSingle1Left();
		final Resource right = input.getMoveSingle1Right();
		final Comparison comparison = compare(left, right);
		final ProtocolChange protocolChange = getAndAssertSingle1ProtocolChange(comparison);
		assertEquals(MOVE, protocolChange.getKind());
		assertEquals(LEFT, protocolChange.getSource());
	}

	@Test
	public void testSingleProtocolMoveInThreeWayLeft() throws IOException {
		final Resource left = input.getMoveSingle1Left();
		final Resource right = input.getMoveSingle1Right();
		final Resource origin = right;
		final Comparison comparison = compare(left, right, origin);
		final ProtocolChange protocolChange = getAndAssertSingle1ProtocolChange(comparison);
		assertEquals(MOVE, protocolChange.getKind());
		assertEquals(LEFT, protocolChange.getSource());
	}

	@Test
	public void testSingleProtocolMoveInThreeWayRight() throws IOException {
		final Resource left = input.getMoveSingle1Left();
		final Resource right = input.getMoveSingle1Right();
		final Resource origin = right;
		final Comparison comparison = compare(right, left, origin);
		final ProtocolChange protocolChange = getAndAssertSingle1ProtocolChange(comparison);
		assertEquals(MOVE, protocolChange.getKind());
		assertEquals(RIGHT, protocolChange.getSource());
	}

	@Test
	public void testSingleProtocolRenameInTwoWay() throws IOException {
		final Resource left = input.getRenameSingle1Left();
		final Resource right = input.getRenameSingle1Right();
		final Comparison comparison = compare(left, right);
		final ProtocolChange protocolChange = getAndAssertSingle1ProtocolChange(comparison);
		assertEquals(CHANGE, protocolChange.getKind());
		assertEquals(LEFT, protocolChange.getSource());
	}

	@Test
	public void testSingleProtocolRenameInThreeWayLeft() throws IOException {
		final Resource left = input.getRenameSingle1Left();
		final Resource right = input.getRenameSingle1Right();
		final Resource origin = right;
		final Comparison comparison = compare(left, right, origin);
		final ProtocolChange protocolChange = getAndAssertSingle1ProtocolChange(comparison);
		assertEquals(CHANGE, protocolChange.getKind());
		assertEquals(LEFT, protocolChange.getSource());
	}

	@Test
	public void testSingleProtocolRenameInThreeWayRight() throws IOException {
		final Resource left = input.getRenameSingle1Left();
		final Resource right = input.getRenameSingle1Right();
		final Resource origin = right;
		final Comparison comparison = compare(right, left, origin);
		final ProtocolChange protocolChange = getAndAssertSingle1ProtocolChange(comparison);
		assertEquals(CHANGE, protocolChange.getKind());
		assertEquals(RIGHT, protocolChange.getSource());
	}

	@Test
	public void testMultipleProtocolChangesInThreeWay() throws IOException {
		final Resource left = input.getMultiple1Left();
		final Resource right = input.getMultiple1Right();
		final Resource origin = input.getMultiple1Origin();
		final Comparison comparison = compare(left, right, origin);
		final List<Diff> differences = comparison.getDifferences();

		// we expect five protocol changes
		final Iterable<ProtocolChange> protocolChanges = filter(differences, ProtocolChange.class);
		assertEquals(5, size(protocolChanges));

		// three on the left, and two on the right
		final Iterable<ProtocolChange> leftProtocolChanges = filter(protocolChanges, fromSide(LEFT));
		final Iterable<ProtocolChange> rightProtocolChanges = filter(protocolChanges, fromSide(RIGHT));
		assertEquals(3, size(leftProtocolChanges));
		assertEquals(2, size(rightProtocolChanges));

		// on the left side, we expect one deletion and one addition
		// DEL: AppControl, ADD: TestProtocol, Rename: Resource
		final Iterable<ProtocolChange> leftDeleteProtocolChanges = filter(leftProtocolChanges, ofKind(DELETE));
		final Iterable<ProtocolChange> leftAddProtocolChanges = filter(leftProtocolChanges, ofKind(ADD));
		final Iterable<ProtocolChange> leftRenameProtocolChanges = filter(leftProtocolChanges, ofKind(CHANGE));
		assertEquals(1, size(leftDeleteProtocolChanges));
		assertEquals(1, size(leftAddProtocolChanges));
		assertEquals(1, size(leftRenameProtocolChanges));
		final ProtocolChange leftDeleteProtocolChange = get(leftDeleteProtocolChanges, 0);
		assertEquals(DELETED_PROTOCOL_NAME_MULTIPLE_1,
				PROTOCOL_CHANGE_COLLABORATION_NAME.apply(leftDeleteProtocolChange));
		final ProtocolChange leftAddProtocolChange = get(leftAddProtocolChanges, 0);
		assertEquals(ADDED_PROTOCOL_NAME_MULTIPLE_1, PROTOCOL_CHANGE_COLLABORATION_NAME.apply(leftAddProtocolChange));
		final ProtocolChange leftRenameProtocolChange = get(leftRenameProtocolChanges, 0);
		assertEquals(RENAMED_PROTOCOL_NAME_MULTIPLE_1,
				PROTOCOL_CHANGE_COLLABORATION_NAME.apply(leftRenameProtocolChange));

		// on the right side, we expect two moves
		// Resource and USBProtocol
		assertEquals(2, size(filter(rightProtocolChanges, ofKind(MOVE))));
		final Iterable<String> movedProtocolNames = transform(rightProtocolChanges, PROTOCOL_CHANGE_COLLABORATION_NAME);
		assertTrue(contains(movedProtocolNames, MOVED_PROTOCOL_MULTIPLE_1_1));
		assertTrue(contains(movedProtocolNames, MOVED_PROTOCOL_MULTIPLE_1_2));
	}

	@Test
	public void testProtocolRenameAndMoveOnResourceProtocolTwoWay() throws IOException {
		final Resource left = input.getMultiple3Origin();
		final Resource right = input.getMultiple3RenameAndMoveOfResource();
		final Comparison comparison = compare(left, right);
		final List<Diff> differences = comparison.getDifferences();
		assertRenameAndMoveProtocolChange(differences, CHANGED_PROTOCOL_NAME_MULTIPLE_3_1);
	}

	@Test
	public void testProtocolRenameAndMoveOnUsbProtocolTwoWay() throws IOException {
		final Resource left = input.getMultiple3Origin();
		final Resource right = input.getMultiple3RenameAndMoveOfUsbProtocol();
		final Comparison comparison = compare(left, right);
		final List<Diff> differences = comparison.getDifferences();
		assertRenameAndMoveProtocolChange(differences, CHANGED_PROTOCOL_NAME_MULTIPLE_3_2);
	}

	@Test
	public void testProtocolRenameAndMoveOnSameProtocolThreeWay() throws IOException {
		final Resource origin = input.getMultiple3Origin();
		final Resource left = input.getMultiple3RenameAndMoveOfResource();
		final Resource right = input.getMultiple3RenameAndMoveOfUsbProtocol();
		final Comparison comparison = compare(left, right, origin);
		final List<Diff> differences = comparison.getDifferences();

		final Iterable<Diff> leftDifferences = filter(differences, fromSide(LEFT));
		assertRenameAndMoveProtocolChange(leftDifferences, RENAMED_PROTOCOL_MULTIPLE_3_1);

		final Iterable<Diff> rightDifferences = filter(differences, fromSide(RIGHT));
		assertRenameAndMoveProtocolChange(rightDifferences, RENAMED_PROTOCOL_MULTIPLE_3_2);
	}

	private void assertRenameAndMoveProtocolChange(Iterable<Diff> differences, String expectedProtocolName) {
		// we expect two protocol changes
		final Iterable<ProtocolChange> protocolChanges = filter(differences, ProtocolChange.class);
		assertEquals(2, size(protocolChanges));

		// one is the move of protocol
		final Iterable<ProtocolChange> protocolMoves = filter(protocolChanges, ofKind(MOVE));
		assertEquals(1, size(protocolMoves));
		final ProtocolChange protocolMove = get(protocolMoves, 0);
		final String nameOfMovedProtocol = PROTOCOL_CHANGE_COLLABORATION_NAME.apply(protocolMove);
		assertEquals(expectedProtocolName, nameOfMovedProtocol);

		// protocol move is refined by one reference change
		final EList<Diff> refiningDiffsOfProtocolMove = protocolMove.getRefinedBy();
		assertEquals(1, refiningDiffsOfProtocolMove.size());
		assertTrue(all(refiningDiffsOfProtocolMove, ofKind(MOVE)));
		assertTrue(all(refiningDiffsOfProtocolMove, instanceOf(ReferenceChange.class)));
		assertTrue(all(refiningDiffsOfProtocolMove, onFeature(UMLPackage.Literals.PACKAGE__PACKAGED_ELEMENT)));

		// one is the rename of protocol
		final Iterable<ProtocolChange> protocolRenames = filter(protocolChanges, ofKind(CHANGE));
		assertEquals(1, size(protocolRenames));
		final ProtocolChange protocolRename = get(protocolRenames, 0);
		final String nameOfRenamedProtocol = PROTOCOL_CHANGE_COLLABORATION_NAME.apply(protocolRename);
		assertEquals(expectedProtocolName, nameOfRenamedProtocol);

		// protocol rename is refined by five attribute changes
		final EList<Diff> refiningDiffsOfProtocolRename = protocolRename.getRefinedBy();
		assertEquals(5, refiningDiffsOfProtocolRename.size());
		assertTrue(all(refiningDiffsOfProtocolRename, ofKind(CHANGE)));
		assertTrue(all(refiningDiffsOfProtocolRename, instanceOf(AttributeChange.class)));
		assertTrue(all(refiningDiffsOfProtocolRename, onFeature(UMLPackage.Literals.NAMED_ELEMENT__NAME)));
	}

	/* ******************* MERGE TESTS ******************* */

	@Test
	public void testMergeSingleProtocolAddInTwoWayRightToLeft() throws IOException {
		final Resource left = input.getAddDeleteSingle2Left();
		final Resource right = input.getAddDeleteSingle2Right();
		Comparison comparison = compare(left, right);

		// we expect one protocol change
		List<ProtocolChange> protocolChanges = getProtocolChanges(comparison);
		assertEquals(1, protocolChanges.size());
		ProtocolChange protocolChange = protocolChanges.get(0);
		assertEquals(ADD, protocolChange.getKind());

		mergeRightToLeft(protocolChange);

		// verify merge
		comparison = compare(left, right);
		assertEquals(0, comparison.getDifferences().size());
	}

	@Test
	public void testMergeSingleProtocolAddInTwoWayLeftToRight() throws IOException {
		final Resource left = input.getAddDeleteSingle2Left();
		final Resource right = input.getAddDeleteSingle2Right();
		Comparison comparison = compare(left, right);

		// we expect one protocol change
		List<ProtocolChange> protocolChanges = getProtocolChanges(comparison);
		assertEquals(1, protocolChanges.size());
		ProtocolChange protocolChange = protocolChanges.get(0);
		assertEquals(ADD, protocolChange.getKind());

		mergeLeftToRight(protocolChange);

		// verify merge
		comparison = compare(left, right);
		assertEquals(0, comparison.getDifferences().size());
	}

	@Test
	public void testMergeSingleProtocolDeleteInTwoWayLeftToRight() throws IOException {
		final Resource left = input.getAddDeleteSingle2Left();
		final Resource right = input.getAddDeleteSingle2Right();
		Comparison comparison = compare(right, left);

		// we expect one protocol change
		List<ProtocolChange> protocolChanges = getProtocolChanges(comparison);
		assertEquals(1, protocolChanges.size());
		ProtocolChange protocolChange = protocolChanges.get(0);
		assertEquals(DELETE, protocolChange.getKind());

		mergeLeftToRight(protocolChange);

		// verify merge
		comparison = compare(left, right);
		assertEquals(0, comparison.getDifferences().size());
	}

	@Test
	public void testMergeSingleProtocolDeleteInTwoWayRightToLeft() throws IOException {
		final Resource left = input.getAddDeleteSingle2Left();
		final Resource right = input.getAddDeleteSingle2Right();
		Comparison comparison = compare(right, left);

		// we expect one protocol change
		List<ProtocolChange> protocolChanges = getProtocolChanges(comparison);
		assertEquals(1, protocolChanges.size());
		ProtocolChange protocolChange = protocolChanges.get(0);
		assertEquals(DELETE, protocolChange.getKind());

		mergeRightToLeft(protocolChange);

		// verify merge
		comparison = compare(left, right);
		assertEquals(0, comparison.getDifferences().size());
	}

	@Test
	public void testMergeSingleProtocolMoveInTwoWayLeftToRight() throws IOException {
		final Resource left = input.getMoveSingle1Left();
		final Resource right = input.getMoveSingle1Right();
		Comparison comparison = compare(left, right);

		// we expect one protocol change
		List<ProtocolChange> protocolChanges = getProtocolChanges(comparison);
		assertEquals(1, protocolChanges.size());
		ProtocolChange protocolChange = protocolChanges.get(0);
		assertEquals(MOVE, protocolChange.getKind());

		mergeLeftToRight(protocolChange);

		// verify merge
		comparison = compare(left, right);
		assertEquals(0, comparison.getDifferences().size());
	}

	@Test
	public void testMergeSingleProtocolMoveInTwoWayRightToLeft() throws IOException {
		final Resource left = input.getMoveSingle1Left();
		final Resource right = input.getMoveSingle1Right();
		Comparison comparison = compare(right, left);

		// we expect one protocol change
		List<ProtocolChange> protocolChanges = getProtocolChanges(comparison);
		assertEquals(1, protocolChanges.size());
		ProtocolChange protocolChange = protocolChanges.get(0);
		assertEquals(MOVE, protocolChange.getKind());

		mergeRightToLeft(protocolChange);

		// verify merge
		comparison = compare(left, right);
		assertEquals(0, comparison.getDifferences().size());
	}

	@Test
	public void testMergeSingleProtocolRenameInTwoWayLeftToRight() throws IOException {
		final Resource left = input.getRenameSingle1Left();
		final Resource right = input.getRenameSingle1Right();
		Comparison comparison = compare(left, right);

		// we expect one protocol change
		List<ProtocolChange> protocolChanges = getProtocolChanges(comparison);
		assertEquals(1, protocolChanges.size());
		ProtocolChange protocolChange = protocolChanges.get(0);
		assertEquals(CHANGE, protocolChange.getKind());

		mergeLeftToRight(protocolChange);

		// verify merge
		comparison = compare(left, right);
		assertEquals(0, comparison.getDifferences().size());
	}

	@Test
	public void testMergeSingleProtocolRenameInTwoWayRightToLeft() throws IOException {
		final Resource left = input.getRenameSingle1Left();
		final Resource right = input.getRenameSingle1Right();
		Comparison comparison = compare(left, right);

		// we expect one protocol change
		List<ProtocolChange> protocolChanges = getProtocolChanges(comparison);
		assertEquals(1, protocolChanges.size());
		ProtocolChange protocolChange = protocolChanges.get(0);
		assertEquals(CHANGE, protocolChange.getKind());

		mergeRightToLeft(protocolChange);

		// verify merge
		comparison = compare(left, right);
		assertEquals(0, comparison.getDifferences().size());
	}

	@Test
	public void testMergeMultipleProtocolAddInTwoWayLeftToRight() throws IOException {
		final Resource left = input.getMultiple2AddRename();
		final Resource right = input.getMultiple2Origin();
		Comparison comparison = compare(left, right);

		// we expect three protocol changes
		List<ProtocolChange> protocolChanges = getProtocolChanges(comparison);
		assertEquals(3, protocolChanges.size());

		ProtocolChange protocol1 = getChangeOfProtocol(protocolChanges, "Protocol1");
		assertNotNull(protocol1);
		ProtocolChange protocol2 = getChangeOfProtocol(protocolChanges, "Protocol2");
		assertNotNull(protocol2);
		ProtocolChange testProtocol = getChangeOfProtocol(protocolChanges, "TestProtocol_newName");
		assertNotNull(testProtocol);

		// accept protocol1 change
		mergeLeftToRight(protocol1);

		// verify merge
		comparison = compare(left, right);
		protocolChanges = getProtocolChanges(comparison);
		assertEquals(2, protocolChanges.size());
		// verify that the other two changes were not merged
		protocol2 = getChangeOfProtocol(protocolChanges, "Protocol2");
		assertNotNull(protocol2);
		testProtocol = getChangeOfProtocol(protocolChanges, "TestProtocol_newName");
		assertNotNull(testProtocol);

		// accept TestProtocol rename change
		mergeLeftToRight(testProtocol);

		// verify merge
		comparison = compare(left, right);
		protocolChanges = getProtocolChanges(comparison);
		assertEquals(1, protocolChanges.size());
		// verify that the other change was not merged
		protocol2 = getChangeOfProtocol(protocolChanges, "Protocol2");
		assertNotNull(protocol2);

		// accept the last change
		mergeLeftToRight(protocol2);
		comparison = compare(left, right);
		assertEquals(0, comparison.getDifferences().size());
	}

	@Test
	public void testMergeMultipleProtocolAddInTwoWayRightToLeft() throws IOException {
		final Resource left = input.getMultiple2AddRename();
		final Resource right = input.getMultiple2Origin();
		Comparison comparison = compare(left, right);

		// we expect three protocol changes
		List<ProtocolChange> protocolChanges = getProtocolChanges(comparison);
		assertEquals(3, protocolChanges.size());

		ProtocolChange protocol1 = getChangeOfProtocol(protocolChanges, "Protocol1");
		assertNotNull(protocol1);
		ProtocolChange protocol2 = getChangeOfProtocol(protocolChanges, "Protocol2");
		assertNotNull(protocol2);
		ProtocolChange testProtocol = getChangeOfProtocol(protocolChanges, "TestProtocol_newName");
		assertNotNull(testProtocol);

		// accept protocol1 change
		mergeRightToLeft(protocol1);

		// verify merge
		comparison = compare(left, right);
		protocolChanges = getProtocolChanges(comparison);
		assertEquals(2, protocolChanges.size());
		// verify that the other two changes were not merged
		protocol2 = getChangeOfProtocol(protocolChanges, "Protocol2");
		assertNotNull(protocol2);
		testProtocol = getChangeOfProtocol(protocolChanges, "TestProtocol_newName");
		assertNotNull(testProtocol);

		// accept TestProtocol rename change
		mergeRightToLeft(testProtocol);

		// verify merge
		comparison = compare(left, right);
		protocolChanges = getProtocolChanges(comparison);
		assertEquals(1, protocolChanges.size());
		// verify that the other change was not merged
		protocol2 = getChangeOfProtocol(protocolChanges, "Protocol2");
		assertNotNull(protocol2);

		// accept the last change
		mergeRightToLeft(protocol2);
		comparison = compare(left, right);
		assertEquals(0, comparison.getDifferences().size());
	}

	@Test
	public void testMergeMultipleProtocolDeleteInTwoWayRightToLeft() throws IOException {
		final Resource right = input.getMultiple2AddRename();
		final Resource left = input.getMultiple2Origin();
		Comparison comparison = compare(left, right);

		// we expect three protocol changes
		List<ProtocolChange> protocolChanges = getProtocolChanges(comparison);
		assertEquals(3, protocolChanges.size());

		ProtocolChange protocol1 = getChangeOfProtocol(protocolChanges, "Protocol1");
		assertNotNull(protocol1);
		ProtocolChange protocol2 = getChangeOfProtocol(protocolChanges, "Protocol2");
		assertNotNull(protocol2);
		ProtocolChange testProtocol = getChangeOfProtocol(protocolChanges, "TestProtocol");
		assertNotNull(testProtocol);

		// accept protocol1 change
		mergeRightToLeft(protocol1);

		// verify merge
		comparison = compare(left, right);
		protocolChanges = getProtocolChanges(comparison);
		assertEquals(2, protocolChanges.size());
		// verify that the other two changes were not merged
		protocol2 = getChangeOfProtocol(protocolChanges, "Protocol2");
		assertNotNull(protocol2);
		testProtocol = getChangeOfProtocol(protocolChanges, "TestProtocol");
		assertNotNull(testProtocol);

		// accept TestProtocol rename change
		mergeRightToLeft(testProtocol);

		// verify merge
		comparison = compare(left, right);
		protocolChanges = getProtocolChanges(comparison);
		assertEquals(1, protocolChanges.size());
		// verify that the other change was not merged
		protocol2 = getChangeOfProtocol(protocolChanges, "Protocol2");
		assertNotNull(protocol2);

		// accept the last change
		mergeRightToLeft(protocol2);
		comparison = compare(left, right);
		assertEquals(0, comparison.getDifferences().size());
	}

	@Test
	public void testMergeMultipleProtocolDeleteInTwoWayLeftToRight() throws IOException {
		final Resource right = input.getMultiple2AddRename();
		final Resource left = input.getMultiple2Origin();
		Comparison comparison = compare(left, right);

		// we expect three protocol changes
		List<ProtocolChange> protocolChanges = getProtocolChanges(comparison);
		assertEquals(3, protocolChanges.size());

		ProtocolChange protocol1 = getChangeOfProtocol(protocolChanges, "Protocol1");
		assertNotNull(protocol1);
		ProtocolChange protocol2 = getChangeOfProtocol(protocolChanges, "Protocol2");
		assertNotNull(protocol2);
		ProtocolChange testProtocol = getChangeOfProtocol(protocolChanges, "TestProtocol");
		assertNotNull(testProtocol);

		// accept protocol1 change
		mergeLeftToRight(protocol1);

		// verify merge
		comparison = compare(left, right);
		protocolChanges = getProtocolChanges(comparison);
		assertEquals(2, protocolChanges.size());
		// verify that the other two changes were not merged
		protocol2 = getChangeOfProtocol(protocolChanges, "Protocol2");
		assertNotNull(protocol2);
		testProtocol = getChangeOfProtocol(protocolChanges, "TestProtocol");
		assertNotNull(testProtocol);

		// accept TestProtocol rename change
		mergeLeftToRight(testProtocol);

		// verify merge
		comparison = compare(left, right);
		protocolChanges = getProtocolChanges(comparison);
		assertEquals(1, protocolChanges.size());
		// verify that the other change was not merged
		protocol2 = getChangeOfProtocol(protocolChanges, "Protocol2");
		assertNotNull(protocol2);

		// accept the last change
		mergeLeftToRight(protocol2);
		comparison = compare(left, right);
		assertEquals(0, comparison.getDifferences().size());
	}

	/* ******************* CONFLICT TESTS ******************* */

	@Test
	public void testProtocolConflictChangeVsDelete() throws IOException {
		final Resource right = input.getMultiple2Delete();
		final Resource left = input.getMultiple2AddRename();
		final Resource origin = input.getMultiple2Origin();

		Comparison comparison = compare(left, right, origin);

		List<ProtocolChange> protocolChanges = getProtocolChanges(comparison);
		assertEquals(4, protocolChanges.size());

		ProtocolChange protocol1 = getChangeOfProtocol(protocolChanges, "Protocol1");
		assertNotNull(protocol1);
		assertEquals(ADD, protocol1.getKind());
		assertEquals(LEFT, protocol1.getSource());

		ProtocolChange protocol2 = getChangeOfProtocol(protocolChanges, "Protocol2");
		assertNotNull(protocol2);
		assertEquals(ADD, protocol2.getKind());
		assertEquals(LEFT, protocol2.getSource());

		ProtocolChange testProtocolRename = getChangeOfProtocol(protocolChanges, "TestProtocol_newName");
		assertNotNull(testProtocolRename);
		assertEquals(CHANGE, testProtocolRename.getKind());
		assertEquals(LEFT, testProtocolRename.getSource());

		ProtocolChange testProtocolDelete = getChangeOfProtocol(protocolChanges, "TestProtocol");
		assertNotNull(testProtocolDelete);
		assertEquals(DELETE, testProtocolDelete.getKind());
		assertEquals(RIGHT, testProtocolDelete.getSource());


		final Conflict conflict = getConflictOrConflictOfRefining(testProtocolRename, ConflictKind.REAL);
		assertNotNull(conflict);
		assertTrue(containsDiffOrAnyOfItsRefiningDiffs(testProtocolDelete, conflict));

		assertNull(getConflictOrConflictOfRefining(testProtocolRename, ConflictKind.PSEUDO));
		assertNull(getConflictOrConflictOfRefining(testProtocolDelete, ConflictKind.PSEUDO));
		assertNull(getConflictOrConflictOfRefining(protocol1, ConflictKind.PSEUDO));
		assertNull(getConflictOrConflictOfRefining(protocol1, ConflictKind.REAL));
		assertNull(getConflictOrConflictOfRefining(protocol2, ConflictKind.PSEUDO));
		assertNull(getConflictOrConflictOfRefining(protocol2, ConflictKind.REAL));
	}

	@Test
	public void testProtocolConflictDeleteVsDelete() throws IOException {
		final Resource right = input.getMultiple2Delete();
		final Resource left = input.getMultiple2Delete();
		final Resource origin = input.getMultiple2Origin();

		Comparison comparison = compare(left, right, origin);

		List<ProtocolChange> protocolChanges = getProtocolChanges(comparison);
		assertEquals(2, protocolChanges.size());

		ProtocolChange testProtocolDeleteLeft = getChangeOfProtocol(filter(protocolChanges, fromSide(LEFT)),
				"TestProtocol");
		assertNotNull(testProtocolDeleteLeft);
		assertEquals(DELETE, testProtocolDeleteLeft.getKind());
		assertEquals(LEFT, testProtocolDeleteLeft.getSource());

		ProtocolChange testProtocolDeleteRight = getChangeOfProtocol(filter(protocolChanges, fromSide(RIGHT)),
				"TestProtocol");
		assertNotNull(testProtocolDeleteRight);
		assertEquals(DELETE, testProtocolDeleteRight.getKind());
		assertEquals(RIGHT, testProtocolDeleteRight.getSource());


		final Conflict conflict = getConflictOrConflictOfRefining(testProtocolDeleteLeft, ConflictKind.PSEUDO);
		assertNotNull(conflict);
		assertTrue(containsDiffOrAnyOfItsRefiningDiffs(testProtocolDeleteRight, conflict));

		assertNull(getConflictOrConflictOfRefining(testProtocolDeleteLeft, ConflictKind.REAL));
		assertNull(getConflictOrConflictOfRefining(testProtocolDeleteRight, ConflictKind.REAL));
	}

	@Test
	public void testProtocolConflictMoveVsMove() throws IOException {
		final Resource right = input.getMultiple2Move();
		final Resource left = input.getMultiple2Move();
		final Resource origin = input.getMultiple2Origin();

		Comparison comparison = compare(left, right, origin);

		List<ProtocolChange> protocolChanges = getProtocolChanges(comparison);
		assertEquals(2, protocolChanges.size());

		ProtocolChange testProtocolMoveLeft = getChangeOfProtocol(filter(protocolChanges, fromSide(LEFT)),
				"TestProtocol");
		assertNotNull(testProtocolMoveLeft);
		assertEquals(MOVE, testProtocolMoveLeft.getKind());
		assertEquals(LEFT, testProtocolMoveLeft.getSource());

		ProtocolChange testProtocolMoveRight = getChangeOfProtocol(filter(protocolChanges, fromSide(RIGHT)),
				"TestProtocol");
		assertNotNull(testProtocolMoveRight);
		assertEquals(MOVE, testProtocolMoveRight.getKind());
		assertEquals(RIGHT, testProtocolMoveRight.getSource());

		final Conflict conflict = getConflictOrConflictOfRefining(testProtocolMoveLeft, ConflictKind.PSEUDO);
		assertNotNull(conflict);
		assertTrue(containsDiffOrAnyOfItsRefiningDiffs(testProtocolMoveRight, conflict));

		assertNull(getConflictOrConflictOfRefining(testProtocolMoveLeft, ConflictKind.REAL));
		assertNull(getConflictOrConflictOfRefining(testProtocolMoveRight, ConflictKind.REAL));

	}

	@Test
	public void testProtocolConflictRenameVsRename() throws IOException {
		final Resource right = input.getMultiple2Rename();
		final Resource left = input.getMultiple2Rename();
		final Resource origin = input.getMultiple2Origin();

		Comparison comparison = compare(left, right, origin);

		List<ProtocolChange> protocolChanges = getProtocolChanges(comparison);
		assertEquals(2, protocolChanges.size());

		ProtocolChange testProtocolRenameLeft = getChangeOfProtocol(filter(protocolChanges, fromSide(LEFT)),
				"TestProtocol");
		assertNotNull(testProtocolRenameLeft);
		assertEquals(CHANGE, testProtocolRenameLeft.getKind());
		assertEquals(LEFT, testProtocolRenameLeft.getSource());

		ProtocolChange testProtocolRenameRight = getChangeOfProtocol(filter(protocolChanges, fromSide(RIGHT)),
				"TestProtocol");
		assertNotNull(testProtocolRenameRight);
		assertEquals(CHANGE, testProtocolRenameRight.getKind());
		assertEquals(RIGHT, testProtocolRenameRight.getSource());

		final Conflict conflict = getConflictOrConflictOfRefining(testProtocolRenameLeft, ConflictKind.PSEUDO);
		assertNotNull(conflict);
		assertTrue(containsDiffOrAnyOfItsRefiningDiffs(testProtocolRenameRight, conflict));

		assertNull(getConflictOrConflictOfRefining(testProtocolRenameLeft, ConflictKind.REAL));
		assertNull(getConflictOrConflictOfRefining(testProtocolRenameRight, ConflictKind.REAL));

	}

	@Test
	public void testProtocolConflictRenameVsMove() throws IOException {
		final Resource right = input.getMultiple2Rename();
		final Resource left = input.getMultiple2Move();
		final Resource origin = input.getMultiple2Origin();

		Comparison comparison = compare(left, right, origin);

		List<ProtocolChange> protocolChanges = getProtocolChanges(comparison);
		assertEquals(2, protocolChanges.size());

		ProtocolChange testProtocolMove = getChangeOfProtocol(filter(protocolChanges, fromSide(LEFT)), "TestProtocol");
		assertNotNull(testProtocolMove);
		assertEquals(MOVE, testProtocolMove.getKind());
		assertEquals(LEFT, testProtocolMove.getSource());

		ProtocolChange testProtocolRename = getChangeOfProtocol(filter(protocolChanges, fromSide(RIGHT)),
				"TestProtocol_newName");
		assertNotNull(testProtocolRename);
		assertEquals(CHANGE, testProtocolRename.getKind());
		assertEquals(RIGHT, testProtocolRename.getSource());

		assertEquals(0, comparison.getConflicts().size());
		assertNull(testProtocolMove.getConflict());
		assertNull(testProtocolRename.getConflict());
	}

	@Test
	public void testProtocolConflictDeleteVsMove() throws IOException {
		final Resource left = input.getMultiple2Delete();
		final Resource right = input.getMultiple2Move();
		final Resource origin = input.getMultiple2Origin();

		Comparison comparison = compare(left, right, origin);

		List<ProtocolChange> protocolChanges = getProtocolChanges(comparison);
		assertEquals(2, protocolChanges.size());

		ProtocolChange testProtocolDelete = getChangeOfProtocol(filter(protocolChanges, fromSide(LEFT)), "TestProtocol");
		assertNotNull(testProtocolDelete);
		assertEquals(DELETE, testProtocolDelete.getKind());
		assertEquals(LEFT, testProtocolDelete.getSource());

		ProtocolChange testProtocolMove = getChangeOfProtocol(filter(protocolChanges, fromSide(RIGHT)), "TestProtocol");
		assertNotNull(testProtocolMove);
		assertEquals(MOVE, testProtocolMove.getKind());
		assertEquals(RIGHT, testProtocolMove.getSource());

		final Conflict conflict = getConflictOrConflictOfRefining(testProtocolDelete, ConflictKind.REAL);
		assertNotNull(conflict);
		assertTrue(containsDiffOrAnyOfItsRefiningDiffs(testProtocolMove, conflict));
	}

	private ProtocolChange getAndAssertSingle1ProtocolChange(Comparison comparison) {
		// we expect one protocol change
		List<ProtocolChange> protocolChanges = getProtocolChanges(comparison);
		assertEquals(1, size(protocolChanges));
		final ProtocolChange protocolChange = protocolChanges.get(0);

		// assert properties of protocol change
		assertProtocolWithName(protocolChange.getDiscriminant(), PROTOCOL_NAME_SINGLE_1);
		return protocolChange;
	}

	private List<ProtocolChange> getProtocolChanges(Comparison comparison) {
		return Lists.newArrayList(filter(comparison.getDifferences(), ProtocolChange.class));
	}

	private void assertProtocolWithName(EObject protocol, String expectedProtocolName) {
		assertTrue(protocol instanceof Collaboration);
		assertEquals(expectedProtocolName, COLLABORATION_NAME.apply(protocol));
	}

	private ProtocolChange getChangeOfProtocol(Iterable<ProtocolChange> protocolChanges, String protocolName) {
		final Optional<ProtocolChange> optional = tryFind(protocolChanges,
				PROTOCOL_CHANGE_WITH_COLLABORATION_NAME_PREDICATE(protocolName));
		return optional.orNull();
	}
}