/*******************************************************************************
 * Copyright (c) 2008-2015 Chair for Applied Software Engineering,
 * Technische Universitaet Muenchen.
 * 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:
 * Maximilian Koegel - initial API and implementation
 ******************************************************************************/
package org.eclipse.emf.emfstore.client.recording.test;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.emfstore.bowling.BowlingFactory;
import org.eclipse.emf.emfstore.bowling.Fan;
import org.eclipse.emf.emfstore.bowling.Merchandise;
import org.eclipse.emf.emfstore.bowling.Tournament;
import org.eclipse.emf.emfstore.client.test.common.cases.ESTest;
import org.eclipse.emf.emfstore.client.test.common.dsl.Create;
import org.eclipse.emf.emfstore.client.test.common.dsl.Delete;
import org.eclipse.emf.emfstore.client.test.common.dsl.TestElementFeatures;
import org.eclipse.emf.emfstore.client.test.common.util.ProjectUtil;
import org.eclipse.emf.emfstore.internal.client.model.exceptions.UnsupportedNotificationException;
import org.eclipse.emf.emfstore.internal.client.model.util.EMFStoreCommand;
import org.eclipse.emf.emfstore.internal.common.model.ModelElementId;
import org.eclipse.emf.emfstore.internal.common.model.Project;
import org.eclipse.emf.emfstore.internal.common.model.util.ModelUtil;
import org.eclipse.emf.emfstore.internal.server.model.versioning.operations.AbstractOperation;
import org.eclipse.emf.emfstore.internal.server.model.versioning.operations.CompositeOperation;
import org.eclipse.emf.emfstore.internal.server.model.versioning.operations.CreateDeleteOperation;
import org.eclipse.emf.emfstore.internal.server.model.versioning.operations.MultiReferenceOperation;
import org.eclipse.emf.emfstore.internal.server.model.versioning.operations.SingleReferenceOperation;
import org.eclipse.emf.emfstore.test.model.TestElement;
import org.junit.Test;

/**
 * Tests the MultiReferenceOperation.
 *
 * @author koegel
 */
public class MultiReferenceOperationTest extends ESTest {

	private static final String M3 = "M3"; //$NON-NLS-1$
	private static final String M2 = "M2"; //$NON-NLS-1$
	private static final String M1 = "M1"; //$NON-NLS-1$

	/**
	 * Change a multi-reference and check the generated operation.
	 */
	@Test
	public void changeMultiReference() throws UnsupportedOperationException, UnsupportedNotificationException {
		final TestElement useCase = Create.testElement();
		final TestElement actor = Create.testElement();
		ProjectUtil.addElement(getProjectSpace().toAPI(), useCase);
		ProjectUtil.addElement(getProjectSpace().toAPI(), actor);

		new EMFStoreCommand() {

			@Override
			protected void doRun() {
				// useCase.setIdentifier("usecase");
				clearOperations();
				actor.getNonContained_1ToN().add(useCase);
			}
		}.run(false);
		assertEquals(actor, useCase.getNonContained_NTo1());
		final EList<TestElement> initiatedTestElements = actor.getNonContained_1ToN();
		assertEquals(1, initiatedTestElements.size());
		assertEquals(useCase, initiatedTestElements.get(0));

		final List<AbstractOperation> operations = forceGetOperations();

		assertEquals(1, operations.size());
		AbstractOperation operation = operations.get(0);
		assertTrue(operation instanceof CompositeOperation);
		final CompositeOperation compositeOperation = (CompositeOperation) operation;

		final List<AbstractOperation> subOperations = compositeOperation.getSubOperations();

		operation = subOperations.get(0);
		assertTrue(operation instanceof SingleReferenceOperation);
		final SingleReferenceOperation singleReferenceOperation = (SingleReferenceOperation) operation;

		final ModelElementId useCaseId = ModelUtil.getProject(useCase).getModelElementId(useCase);
		final ModelElementId actorId = ModelUtil.getProject(actor).getModelElementId(actor);

		assertEquals(TestElementFeatures.nonContainedNTo1().getName(),
			singleReferenceOperation.getFeatureName());
		assertEquals(TestElementFeatures.nonContained1ToN().getName(),
			singleReferenceOperation.getOppositeFeatureName());
		assertEquals(useCaseId, singleReferenceOperation.getModelElementId());
		assertEquals(actorId, singleReferenceOperation.getNewValue());
		assertNull(singleReferenceOperation.getOldValue());
		assertTrue(singleReferenceOperation.isBidirectional());

		operation = subOperations.get(1);
		assertTrue(operation instanceof MultiReferenceOperation);
		final MultiReferenceOperation multiReferenceOperation = (MultiReferenceOperation) operation;

		assertEquals(TestElementFeatures.nonContained1ToN().getName(), multiReferenceOperation.getFeatureName());
		assertEquals(0, multiReferenceOperation.getIndex());
		assertEquals(actorId, multiReferenceOperation.getModelElementId());
		assertEquals(TestElementFeatures.nonContainedNTo1().getName(),
			multiReferenceOperation.getOppositeFeatureName());
		assertTrue(multiReferenceOperation.isAdd());
		assertTrue(multiReferenceOperation.isBidirectional());

		final EList<ModelElementId> referencedModelElements = multiReferenceOperation.getReferencedModelElements();
		assertEquals(1, referencedModelElements.size());
		assertEquals(useCaseId, referencedModelElements.get(0));

		final Set<ModelElementId> otherInvolvedModelElements = multiReferenceOperation.getOtherInvolvedModelElements();
		assertEquals(1, otherInvolvedModelElements.size());
		assertTrue(otherInvolvedModelElements.contains(useCaseId));

	}

	/**
	 * Change a multi reference and check the generated operation.
	 */
	@Test
	public void reverseMultiReference() throws UnsupportedOperationException, UnsupportedNotificationException {
		final TestElement useCase = Create.testElement();
		final TestElement actor = Create.testElement();

		new EMFStoreCommand() {

			@Override
			protected void doRun() {
				// useCase.setIdentifier("usecase1");
				getProject().addModelElement(useCase);
				getProject().addModelElement(actor);

				clearOperations();

				actor.getNonContained_1ToN().add(useCase);

				assertEquals(actor, useCase.getNonContained_NTo1());
				final EList<TestElement> initiatedTestElements = actor.getNonContained_1ToN();
				assertEquals(1, initiatedTestElements.size());
				assertEquals(useCase, initiatedTestElements.get(0));
			}
		}.run(false);

		final List<AbstractOperation> operations = forceGetOperations();

		assertEquals(1, operations.size());
		final AbstractOperation comp = operations.get(0);
		assertTrue(comp instanceof CompositeOperation);

		final List<AbstractOperation> subOperations = ((CompositeOperation) comp).getSubOperations();

		assertEquals(2, subOperations.size());

		// skipping singlereference op
		final AbstractOperation operation = subOperations.get(1);
		assertTrue(operation instanceof MultiReferenceOperation);
		final MultiReferenceOperation multiReferenceOperation = (MultiReferenceOperation) operation;

		final AbstractOperation reverse = multiReferenceOperation.reverse();
		assertTrue(reverse instanceof MultiReferenceOperation);

		final ModelElementId actorId = ModelUtil.getProject(actor).getModelElementId(actor);
		final ModelElementId useCaseId = ModelUtil.getProject(useCase).getModelElementId(useCase);

		final MultiReferenceOperation reversedMultiReferenceOperation = (MultiReferenceOperation) reverse;
		assertEquals(TestElementFeatures.nonContained1ToN().getName(),
			reversedMultiReferenceOperation.getFeatureName());
		assertEquals(0, reversedMultiReferenceOperation.getIndex());
		assertEquals(actorId, reversedMultiReferenceOperation.getModelElementId());
		assertEquals(TestElementFeatures.nonContainedNTo1().getName(),
			reversedMultiReferenceOperation.getOppositeFeatureName());
		assertFalse(reversedMultiReferenceOperation.isAdd());
		assertTrue(reversedMultiReferenceOperation.isBidirectional());

		final EList<ModelElementId> referencedModelElements = reversedMultiReferenceOperation
			.getReferencedModelElements();
		assertEquals(1, referencedModelElements.size());
		assertEquals(useCaseId, referencedModelElements.get(0));

		final Set<ModelElementId> otherInvolvedModelElements = reversedMultiReferenceOperation
			.getOtherInvolvedModelElements();
		assertEquals(1, otherInvolvedModelElements.size());
		assertTrue(otherInvolvedModelElements.contains(useCaseId));

		new EMFStoreCommand() {

			@Override
			protected void doRun() {
				reversedMultiReferenceOperation.apply(getProject());
			}
		}.run(false);

		assertEquals(0, actor.getNonContained_1ToN().size());
		assertNull(useCase.getNonContained_NTo1());
	}

	/**
	 * Change a multi reference and check the generated operation.
	 */
	// BEGIN COMPLEX CODE
	@Test
	public void addManyMultiReference() throws UnsupportedOperationException, UnsupportedNotificationException {
		final TestElement useCase = Create.testElement();
		final TestElement actor = Create.testElement();
		final TestElement useCase2 = Create.testElement();
		final TestElement useCase3 = Create.testElement();
		final List<TestElement> useCases = new ArrayList<TestElement>();
		useCases.add(useCase);
		useCases.add(useCase2);
		useCases.add(useCase3);

		new EMFStoreCommand() {

			@Override
			protected void doRun() {
				// useCase.setIdentifier("usecase1");
				getProject().addModelElement(useCase);
				getProject().addModelElement(actor);
				// useCase2.setIdentifier("usecase2");
				getProject().addModelElement(useCase2);
				// useCase3.setIdentifier("usecase3");
				getProject().addModelElement(useCase3);
				clearOperations();

				actor.getNonContained_1ToN().addAll(useCases);

				assertEquals(actor, useCase.getNonContained_NTo1());
				assertEquals(actor, useCase2.getNonContained_NTo1());
				assertEquals(actor, useCase3.getNonContained_NTo1());
				final EList<TestElement> initiatedTestElements = actor.getNonContained_1ToN();
				assertEquals(3, initiatedTestElements.size());
				assertEquals(useCase, initiatedTestElements.get(0));
				assertEquals(useCase2, initiatedTestElements.get(1));
				assertEquals(useCase3, initiatedTestElements.get(2));
			}
		}.run(false);

		final List<AbstractOperation> operations = forceGetOperations();

		assertEquals(1, operations.size());
		AbstractOperation operation = operations.get(0);
		assertTrue(operation instanceof CompositeOperation);
		final CompositeOperation compositeOperation = (CompositeOperation) operation;

		final List<AbstractOperation> subOperations = compositeOperation.getSubOperations();

		assertEquals(4, subOperations.size());

		final ModelElementId actorId = ModelUtil.getProject(actor).getModelElementId(actor);
		final ModelElementId useCaseId = ModelUtil.getProject(useCase).getModelElementId(useCase);
		final ModelElementId useCase2Id = ModelUtil.getProject(useCase2).getModelElementId(useCase2);
		final ModelElementId useCase3Id = ModelUtil.getProject(useCase3).getModelElementId(useCase3);

		for (int i = 0; i < 3; i++) {
			final AbstractOperation opn = subOperations.get(i);
			assertTrue(opn instanceof SingleReferenceOperation);
			final SingleReferenceOperation singleReferenceOperation = (SingleReferenceOperation) opn;

			assertEquals(TestElementFeatures.nonContainedNTo1().getName(), singleReferenceOperation.getFeatureName());
			assertEquals(TestElementFeatures.nonContained1ToN().getName(),
				singleReferenceOperation.getOppositeFeatureName());
			assertEquals(ModelUtil.getProject(useCases.get(i)).getModelElementId(useCases.get(i)),
				singleReferenceOperation.getModelElementId());
			assertNull(singleReferenceOperation.getOldValue());
			assertEquals(actorId, singleReferenceOperation.getNewValue());
			assertTrue(singleReferenceOperation.isBidirectional());
		}

		operation = subOperations.get(3);
		assertTrue(operation instanceof MultiReferenceOperation);
		final MultiReferenceOperation multiReferenceOperation = (MultiReferenceOperation) operation;

		assertEquals(TestElementFeatures.nonContained1ToN().getName(), multiReferenceOperation.getFeatureName());
		assertEquals(0, multiReferenceOperation.getIndex());
		assertEquals(actorId, multiReferenceOperation.getModelElementId());
		assertEquals(TestElementFeatures.nonContainedNTo1().getName(),
			multiReferenceOperation.getOppositeFeatureName());
		assertTrue(multiReferenceOperation.isAdd());
		assertTrue(multiReferenceOperation.isBidirectional());

		final EList<ModelElementId> referencedModelElements = multiReferenceOperation.getReferencedModelElements();
		assertEquals(3, referencedModelElements.size());
		assertEquals(useCaseId, referencedModelElements.get(0));
		assertEquals(useCase2Id, referencedModelElements.get(1));
		assertEquals(useCase3Id, referencedModelElements.get(2));

		final Set<ModelElementId> otherInvolvedModelElements = multiReferenceOperation.getOtherInvolvedModelElements();
		assertEquals(3, otherInvolvedModelElements.size());
		assertTrue(otherInvolvedModelElements.contains(useCaseId));
		assertTrue(otherInvolvedModelElements.contains(useCase2Id));
		assertTrue(otherInvolvedModelElements.contains(useCase3Id));
	}

	// END COMPLEX CODE

	/**
	 * Change a multi reference and check the generated operation.
	 */
	// BEGIN COMPLEX CODE
	@Test
	public void removeManyMultiReference() throws UnsupportedOperationException, UnsupportedNotificationException {
		final TestElement useCase = Create.testElement();
		final TestElement actor = Create.testElement();
		final TestElement useCase2 = Create.testElement();
		final TestElement useCase3 = Create.testElement();
		final List<TestElement> useCases = new ArrayList<TestElement>();
		useCases.add(useCase);
		useCases.add(useCase2);
		useCases.add(useCase3);

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				getProject().addModelElement(useCase);
				getProject().addModelElement(actor);
				getProject().addModelElement(useCase2);
				getProject().addModelElement(useCase3);
				actor.getNonContained_1ToN().addAll(useCases);

				clearOperations();

				assertEquals(actor, useCase.getNonContained_NTo1());
				assertEquals(actor, useCase2.getNonContained_NTo1());
				assertEquals(actor, useCase3.getNonContained_NTo1());
				final EList<TestElement> initiatedTestElements = actor.getNonContained_1ToN();
				assertEquals(3, initiatedTestElements.size());
				assertEquals(useCase, initiatedTestElements.get(0));
				assertEquals(useCase2, initiatedTestElements.get(1));
				assertEquals(useCase3, initiatedTestElements.get(2));
			}
		}.run(false);

		Delete.fromNonContained1ToN(actor, useCases);

		assertNull(useCase.getNonContained_NTo1());
		assertNull(useCase2.getNonContained_NTo1());
		assertNull(useCase3.getNonContained_NTo1());
		assertEquals(0, actor.getNonContained_1ToN().size());

		final List<AbstractOperation> operations = forceGetOperations();

		assertEquals(1, operations.size());

		final List<AbstractOperation> subOperations = checkAndCast(operations.get(0),
			CompositeOperation.class).getSubOperations();

		assertEquals(4, subOperations.size());

		final ModelElementId actorId = getProject().getModelElementId(actor);
		final ModelElementId useCaseId = getProject().getModelElementId(useCase);
		final ModelElementId useCase2Id = getProject().getModelElementId(useCase2);
		final ModelElementId useCase3Id = getProject().getModelElementId(useCase3);

		for (int i = 0; i < 3; i++) {
			final SingleReferenceOperation singleReferenceOperation = checkAndCast(subOperations.get(i),
				SingleReferenceOperation.class);

			assertEquals(TestElementFeatures.nonContainedNTo1().getName(),
				singleReferenceOperation.getFeatureName());
			assertEquals(TestElementFeatures.nonContained1ToN().getName(),
				singleReferenceOperation.getOppositeFeatureName());
			assertEquals(ModelUtil.getProject(useCases.get(i)).getModelElementId(useCases.get(i)),
				singleReferenceOperation.getModelElementId());
			assertEquals(actorId, singleReferenceOperation.getOldValue());
			assertNull(singleReferenceOperation.getNewValue());
			assertTrue(singleReferenceOperation.isBidirectional());
		}

		final MultiReferenceOperation multiReferenceOperation = checkAndCast(subOperations.get(3),
			MultiReferenceOperation.class);

		assertEquals(TestElementFeatures.nonContained1ToN().getName(), multiReferenceOperation.getFeatureName());
		assertEquals(0, multiReferenceOperation.getIndex());
		assertEquals(actorId, multiReferenceOperation.getModelElementId());
		assertEquals(TestElementFeatures.nonContainedNTo1().getName(),
			multiReferenceOperation.getOppositeFeatureName());
		assertFalse(multiReferenceOperation.isAdd());
		assertTrue(multiReferenceOperation.isBidirectional());

		final EList<ModelElementId> referencedModelElements = multiReferenceOperation.getReferencedModelElements();
		assertEquals(3, referencedModelElements.size());
		assertEquals(useCaseId, referencedModelElements.get(0));
		assertEquals(useCase2Id, referencedModelElements.get(1));
		assertEquals(useCase3Id, referencedModelElements.get(2));

		final Set<ModelElementId> otherInvolvedModelElements = multiReferenceOperation.getOtherInvolvedModelElements();
		assertEquals(3, otherInvolvedModelElements.size());
		assertTrue(otherInvolvedModelElements.contains(useCaseId));
		assertTrue(otherInvolvedModelElements.contains(useCase2Id));
		assertTrue(otherInvolvedModelElements.contains(useCase3Id));
	}

	// END COMPLEX CODE

	@Test
	public void unsetMultiReferenceTest() {
		final Fan fan = BowlingFactory.eINSTANCE.createFan();
		final Tournament tournament1 = BowlingFactory.eINSTANCE.createTournament();
		final Tournament tournament2 = BowlingFactory.eINSTANCE.createTournament();
		final Tournament tournament3 = BowlingFactory.eINSTANCE.createTournament();

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				getProject().addModelElement(fan);
				getProject().addModelElement(tournament1);
				getProject().addModelElement(tournament2);
				getProject().addModelElement(tournament3);
				fan.getVisitedTournaments().add(tournament1);
				fan.getVisitedTournaments().add(tournament2);
				fan.getVisitedTournaments().add(tournament3);
				assertEquals(3, fan.getVisitedTournaments().size());
				assertTrue(fan.isSetVisitedTournaments());
			}
		}.run(false);

		clearOperations();
		final Project secondProject = ModelUtil.clone(getProject());

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				fan.unsetVisitedTournaments();
				assertEquals(0, fan.getVisitedTournaments().size());
				assertTrue(!fan.isSetVisitedTournaments());
				assertTrue(getProject().getAllModelElements().contains(tournament1));
				assertTrue(getProject().getAllModelElements().contains(tournament2));
				assertTrue(getProject().getAllModelElements().contains(tournament3));
			}
		}.run(false);

		final List<AbstractOperation> operations = forceGetOperations();

		assertEquals(2, operations.size());

		final AbstractOperation operation = operations.get(0);
		assertTrue(operation instanceof MultiReferenceOperation);
		final MultiReferenceOperation mrop1 = (MultiReferenceOperation) operation;

		final AbstractOperation operation2 = operations.get(1);
		assertTrue(operation2 instanceof MultiReferenceOperation);
		final MultiReferenceOperation mrop2 = (MultiReferenceOperation) operation2;

		final ModelElementId fanId = ModelUtil.getProject(fan).getModelElementId(fan);
		assertEquals(fanId, mrop1.getModelElementId());
		assertEquals(fanId, mrop2.getModelElementId());

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				operations.get(0).apply(secondProject);
				operations.get(1).apply(secondProject);
			}
		}.run(false);

		assertEquals(0, ((Fan) secondProject.getModelElements().get(0)).getVisitedTournaments().size());
		assertTrue(!((Fan) secondProject.getModelElements().get(0)).isSetVisitedTournaments());
		assertTrue(ModelUtil.areEqual(getProject(), secondProject));
	}

	@Test
	public void reverseUnsetMultiReferenceTest() {
		final Fan fan = BowlingFactory.eINSTANCE.createFan();
		final Tournament tournament1 = BowlingFactory.eINSTANCE.createTournament();
		final Tournament tournament2 = BowlingFactory.eINSTANCE.createTournament();
		final Tournament tournament3 = BowlingFactory.eINSTANCE.createTournament();

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				getProject().addModelElement(fan);
				getProject().addModelElement(tournament1);
				getProject().addModelElement(tournament2);
				getProject().addModelElement(tournament3);
				fan.getVisitedTournaments().add(tournament1);
				fan.getVisitedTournaments().add(tournament2);
				fan.getVisitedTournaments().add(tournament3);
				assertEquals(3, fan.getVisitedTournaments().size());
				assertTrue(fan.isSetVisitedTournaments());
			}
		}.run(false);

		clearOperations();
		final Project secondProject = ModelUtil.clone(getProject());

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				fan.unsetVisitedTournaments();
				assertEquals(0, fan.getVisitedTournaments().size());
				assertTrue(!fan.isSetVisitedTournaments());
				assertTrue(getProject().getAllModelElements().contains(tournament1));
				assertTrue(getProject().getAllModelElements().contains(tournament2));
				assertTrue(getProject().getAllModelElements().contains(tournament3));
			}
		}.run(false);

		final List<AbstractOperation> operations = forceGetOperations();

		assertEquals(2, operations.size());

		final AbstractOperation operation = operations.get(0);
		assertTrue(operation instanceof MultiReferenceOperation);
		final MultiReferenceOperation mrop1 = (MultiReferenceOperation) operation;

		final AbstractOperation operation2 = operations.get(1);
		assertTrue(operation2 instanceof MultiReferenceOperation);
		final MultiReferenceOperation mrop2 = (MultiReferenceOperation) operation2;

		final ModelElementId fanId = ModelUtil.getProject(fan).getModelElementId(fan);
		assertEquals(fanId, mrop1.getModelElementId());
		assertEquals(fanId, mrop2.getModelElementId());

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				mrop2.reverse().apply(getProject());
				mrop1.reverse().apply(getProject());
			}
		}.run(false);

		assertEquals(3, fan.getVisitedTournaments().size());
		assertTrue(fan.getVisitedTournaments().contains(tournament1));
		assertTrue(fan.getVisitedTournaments().contains(tournament2));
		assertTrue(fan.getVisitedTournaments().contains(tournament3));
		assertTrue(fan.isSetVisitedTournaments());
		assertTrue(ModelUtil.areEqual(getProject(), secondProject));
	}

	@Test
	public void doubleReverseUnsetMultiReferenceTest() {
		final Fan fan = BowlingFactory.eINSTANCE.createFan();
		final Tournament tournament1 = BowlingFactory.eINSTANCE.createTournament();
		final Tournament tournament2 = BowlingFactory.eINSTANCE.createTournament();
		final Tournament tournament3 = BowlingFactory.eINSTANCE.createTournament();

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				getProject().addModelElement(fan);
				getProject().addModelElement(tournament1);
				getProject().addModelElement(tournament2);
				getProject().addModelElement(tournament3);
				fan.getVisitedTournaments().add(tournament1);
				fan.getVisitedTournaments().add(tournament2);
				fan.getVisitedTournaments().add(tournament3);
				assertEquals(3, fan.getVisitedTournaments().size());
				assertTrue(fan.isSetVisitedTournaments());
			}
		}.run(false);

		clearOperations();

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				fan.unsetVisitedTournaments();
				assertEquals(0, fan.getVisitedTournaments().size());
				assertTrue(!fan.isSetVisitedTournaments());
				assertTrue(getProject().getAllModelElements().contains(tournament1));
				assertTrue(getProject().getAllModelElements().contains(tournament2));
				assertTrue(getProject().getAllModelElements().contains(tournament3));
			}
		}.run(false);

		final Project secondProject = ModelUtil.clone(getProject());
		final List<AbstractOperation> operations = forceGetOperations();

		assertEquals(2, operations.size());

		final AbstractOperation operation = operations.get(0);
		assertTrue(operation instanceof MultiReferenceOperation);
		final MultiReferenceOperation mrop1 = (MultiReferenceOperation) operation;

		final AbstractOperation operation2 = operations.get(1);
		assertTrue(operation2 instanceof MultiReferenceOperation);
		final MultiReferenceOperation mrop2 = (MultiReferenceOperation) operation2;

		final ModelElementId fanId = ModelUtil.getProject(fan).getModelElementId(fan);
		assertEquals(fanId, mrop1.getModelElementId());
		assertEquals(fanId, mrop2.getModelElementId());

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				mrop1.reverse().reverse().apply(getProject());
				mrop2.reverse().reverse().apply(getProject());
			}
		}.run(false);

		assertEquals(0, fan.getVisitedTournaments().size());
		assertTrue(!fan.isSetVisitedTournaments());
		assertTrue(getProject().getAllModelElements().contains(tournament1));
		assertTrue(getProject().getAllModelElements().contains(tournament2));
		assertTrue(getProject().getAllModelElements().contains(tournament3));
		assertTrue(ModelUtil.areEqual(getProject(), secondProject));
	}

	@Test
	public void reverseSetOfUnsettedMultiReferenceTest() {
		final Fan fan = BowlingFactory.eINSTANCE.createFan();
		final Tournament tournament1 = BowlingFactory.eINSTANCE.createTournament();
		final Tournament tournament2 = BowlingFactory.eINSTANCE.createTournament();
		final Tournament tournament3 = BowlingFactory.eINSTANCE.createTournament();

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				getProject().addModelElement(fan);
				getProject().addModelElement(tournament1);
				getProject().addModelElement(tournament2);
				getProject().addModelElement(tournament3);
				assertEquals(0, fan.getVisitedTournaments().size());
				assertTrue(!fan.isSetVisitedTournaments());
				assertTrue(getProject().getAllModelElements().contains(tournament1));
				assertTrue(getProject().getAllModelElements().contains(tournament2));
				assertTrue(getProject().getAllModelElements().contains(tournament3));
			}
		}.run(false);

		clearOperations();
		final Project secondProject = ModelUtil.clone(getProject());

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				fan.getVisitedTournaments().add(tournament1);
				fan.getVisitedTournaments().add(tournament2);
				fan.getVisitedTournaments().add(tournament3);
				assertEquals(3, fan.getVisitedTournaments().size());
				assertTrue(fan.isSetVisitedTournaments());
			}
		}.run(false);

		final List<AbstractOperation> operations = forceGetOperations();

		assertEquals(3, operations.size());

		final AbstractOperation operation = operations.get(0);
		assertTrue(operation instanceof MultiReferenceOperation);
		final MultiReferenceOperation mrop1 = (MultiReferenceOperation) operation;

		final AbstractOperation operation2 = operations.get(1);
		assertTrue(operation2 instanceof MultiReferenceOperation);
		final MultiReferenceOperation mrop2 = (MultiReferenceOperation) operation2;

		final AbstractOperation operation3 = operations.get(2);
		assertTrue(operation3 instanceof MultiReferenceOperation);
		final MultiReferenceOperation mrop3 = (MultiReferenceOperation) operation3;

		final ModelElementId fanId = ModelUtil.getProject(fan).getModelElementId(fan);
		assertEquals(fanId, mrop1.getModelElementId());
		assertEquals(fanId, mrop2.getModelElementId());
		assertEquals(fanId, mrop3.getModelElementId());

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				mrop3.reverse().apply(getProject());
				mrop2.reverse().apply(getProject());
				mrop1.reverse().apply(getProject());
			}
		}.run(false);

		assertEquals(0, fan.getVisitedTournaments().size());
		assertTrue(!fan.isSetVisitedTournaments());
		assertTrue(ModelUtil.areEqual(getProject(), secondProject));
	}

	// BEGIN COMPLEX CODE
	@Test
	public void unsetMultiContainmentReferenceTest() {
		final Fan fan = BowlingFactory.eINSTANCE.createFan();
		final Merchandise merch1 = BowlingFactory.eINSTANCE.createMerchandise();
		final Merchandise merch2 = BowlingFactory.eINSTANCE.createMerchandise();
		final Merchandise merch3 = BowlingFactory.eINSTANCE.createMerchandise();

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				getProject().addModelElement(fan);
				getProject().addModelElement(merch1);
				getProject().addModelElement(merch2);
				getProject().addModelElement(merch3);
				fan.getFanMerchandise().add(merch1);
				fan.getFanMerchandise().add(merch2);
				fan.getFanMerchandise().add(merch3);
				assertEquals(3, fan.getFanMerchandise().size());
				assertTrue(fan.isSetFanMerchandise());
			}
		}.run(false);

		clearOperations();
		final Project secondProject = ModelUtil.clone(getProject());

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				fan.unsetFanMerchandise();
				assertEquals(0, fan.getFanMerchandise().size());
				assertTrue(!fan.isSetFanMerchandise());
				assertTrue(!getProject().getAllModelElements().contains(merch1));
				assertTrue(!getProject().getAllModelElements().contains(merch2));
				assertTrue(!getProject().getAllModelElements().contains(merch3));
			}
		}.run(false);

		final List<AbstractOperation> operations = forceGetOperations();

		assertEquals(5, operations.size());

		final AbstractOperation operation = operations.get(0);
		assertTrue(operation instanceof MultiReferenceOperation);
		final MultiReferenceOperation mrop1 = (MultiReferenceOperation) operation;

		final AbstractOperation operation2 = operations.get(1);
		assertTrue(operation2 instanceof MultiReferenceOperation);
		final MultiReferenceOperation mrop2 = (MultiReferenceOperation) operation2;

		final AbstractOperation operation3 = operations.get(2);
		assertTrue(operation3 instanceof CreateDeleteOperation);
		final CreateDeleteOperation creaDelOp1 = (CreateDeleteOperation) operation3;

		final AbstractOperation operation4 = operations.get(3);
		assertTrue(operation4 instanceof CreateDeleteOperation);
		final CreateDeleteOperation creaDelOp2 = (CreateDeleteOperation) operation4;

		final AbstractOperation operation5 = operations.get(4);
		assertTrue(operation5 instanceof CreateDeleteOperation);
		final CreateDeleteOperation creaDelOp3 = (CreateDeleteOperation) operation5;

		final ModelElementId fanId = ModelUtil.getProject(fan).getModelElementId(fan);
		assertEquals(fanId, mrop1.getModelElementId());
		assertEquals(fanId, mrop2.getModelElementId());

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				mrop1.apply(secondProject);
				mrop2.apply(secondProject);
				creaDelOp1.apply(secondProject);
				creaDelOp2.apply(secondProject);
				creaDelOp3.apply(secondProject);
			}
		}.run(false);

		assertEquals(0, ((Fan) secondProject.getModelElements().get(0)).getFanMerchandise().size());
		assertTrue(!((Fan) secondProject.getModelElements().get(0)).isSetFanMerchandise());
		assertTrue(ModelUtil.areEqual(getProject(), secondProject));
	}

	// END COMPLEX CODE

	// BEGIN COMPLEX CODE
	@Test
	public void reverseUnsetMultiContainmentReferenceTest() {
		final Fan fan = BowlingFactory.eINSTANCE.createFan();
		final Merchandise merch1 = BowlingFactory.eINSTANCE.createMerchandise();
		final Merchandise merch2 = BowlingFactory.eINSTANCE.createMerchandise();
		final Merchandise merch3 = BowlingFactory.eINSTANCE.createMerchandise();

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				getProject().addModelElement(fan);
				getProject().addModelElement(merch1);
				getProject().addModelElement(merch2);
				getProject().addModelElement(merch3);
				fan.getFanMerchandise().add(merch1);
				fan.getFanMerchandise().add(merch2);
				fan.getFanMerchandise().add(merch3);
				assertEquals(3, fan.getFanMerchandise().size());
				assertTrue(fan.isSetFanMerchandise());
			}
		}.run(false);

		clearOperations();
		final Project secondProject = ModelUtil.clone(getProject());

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				fan.unsetFanMerchandise();
				assertEquals(0, fan.getFanMerchandise().size());
				assertTrue(!fan.isSetFanMerchandise());
				assertTrue(!getProject().getAllModelElements().contains(merch1));
				assertTrue(!getProject().getAllModelElements().contains(merch2));
				assertTrue(!getProject().getAllModelElements().contains(merch3));
			}
		}.run(false);

		final List<AbstractOperation> operations = forceGetOperations();

		assertEquals(5, operations.size());

		final AbstractOperation operation = operations.get(0);
		assertTrue(operation instanceof MultiReferenceOperation);
		final MultiReferenceOperation mrop1 = (MultiReferenceOperation) operation;

		final AbstractOperation operation2 = operations.get(1);
		assertTrue(operation2 instanceof MultiReferenceOperation);
		final MultiReferenceOperation mrop2 = (MultiReferenceOperation) operation2;

		final AbstractOperation operation3 = operations.get(2);
		assertTrue(operation3 instanceof CreateDeleteOperation);
		final CreateDeleteOperation creaDelOp1 = (CreateDeleteOperation) operation3;

		final AbstractOperation operation4 = operations.get(3);
		assertTrue(operation4 instanceof CreateDeleteOperation);
		final CreateDeleteOperation creaDelOp2 = (CreateDeleteOperation) operation4;

		final AbstractOperation operation5 = operations.get(4);
		assertTrue(operation5 instanceof CreateDeleteOperation);
		final CreateDeleteOperation creaDelOp3 = (CreateDeleteOperation) operation5;

		final ModelElementId fanId = ModelUtil.getProject(fan).getModelElementId(fan);
		assertEquals(fanId, mrop1.getModelElementId());
		assertEquals(fanId, mrop2.getModelElementId());

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				creaDelOp3.reverse().apply(getProject());
				creaDelOp2.reverse().apply(getProject());
				creaDelOp1.reverse().apply(getProject());
				mrop2.reverse().apply(getProject());
				mrop1.reverse().apply(getProject());
			}
		}.run(false);

		assertEquals(3, fan.getFanMerchandise().size());
		assertTrue(fan.isSetFanMerchandise());
		assertTrue(ModelUtil.areEqual(getProject(), secondProject));
	}

	// END COMPLEX CODE

	// BEGIN COMPLEX CODE
	@Test
	public void doubleReverseUnsetMultiContainmentReferenceTest() {
		final Fan fan = BowlingFactory.eINSTANCE.createFan();
		final Merchandise merch1 = BowlingFactory.eINSTANCE.createMerchandise();
		final Merchandise merch2 = BowlingFactory.eINSTANCE.createMerchandise();
		final Merchandise merch3 = BowlingFactory.eINSTANCE.createMerchandise();

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				getProject().addModelElement(fan);
				getProject().addModelElement(merch1);
				getProject().addModelElement(merch2);
				getProject().addModelElement(merch3);
				fan.getFanMerchandise().add(merch1);
				fan.getFanMerchandise().add(merch2);
				fan.getFanMerchandise().add(merch3);
				assertEquals(3, fan.getFanMerchandise().size());
				assertTrue(fan.isSetFanMerchandise());
			}
		}.run(false);

		clearOperations();

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				fan.unsetFanMerchandise();
				assertEquals(0, fan.getFanMerchandise().size());
				assertTrue(!fan.isSetFanMerchandise());
				assertTrue(!getProject().getAllModelElements().contains(merch1));
				assertTrue(!getProject().getAllModelElements().contains(merch2));
				assertTrue(!getProject().getAllModelElements().contains(merch3));
			}
		}.run(false);

		final Project secondProject = ModelUtil.clone(getProject());

		final List<AbstractOperation> operations = forceGetOperations();

		assertEquals(5, operations.size());

		final AbstractOperation operation = operations.get(0);
		assertTrue(operation instanceof MultiReferenceOperation);
		final MultiReferenceOperation mrop1 = (MultiReferenceOperation) operation;

		final AbstractOperation operation2 = operations.get(1);
		assertTrue(operation2 instanceof MultiReferenceOperation);
		final MultiReferenceOperation mrop2 = (MultiReferenceOperation) operation2;

		final AbstractOperation operation3 = operations.get(2);
		assertTrue(operation3 instanceof CreateDeleteOperation);
		final CreateDeleteOperation creaDelOp1 = (CreateDeleteOperation) operation3;

		final AbstractOperation operation4 = operations.get(3);
		assertTrue(operation4 instanceof CreateDeleteOperation);
		final CreateDeleteOperation creaDelOp2 = (CreateDeleteOperation) operation4;

		final AbstractOperation operation5 = operations.get(4);
		assertTrue(operation5 instanceof CreateDeleteOperation);
		final CreateDeleteOperation creaDelOp3 = (CreateDeleteOperation) operation5;

		final ModelElementId fanId = ModelUtil.getProject(fan).getModelElementId(fan);
		assertEquals(fanId, mrop1.getModelElementId());
		assertEquals(fanId, mrop2.getModelElementId());

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				mrop1.reverse().reverse().apply(getProject());
				mrop2.reverse().reverse().apply(getProject());
				creaDelOp1.reverse().reverse().apply(getProject());
				creaDelOp2.reverse().reverse().apply(getProject());
				creaDelOp3.reverse().reverse().apply(getProject());
			}
		}.run(false);

		assertEquals(0, fan.getFanMerchandise().size());
		assertTrue(!fan.isSetFanMerchandise());
		assertTrue(!getProject().getAllModelElements().contains(merch1));
		assertTrue(!getProject().getAllModelElements().contains(merch2));
		assertTrue(!getProject().getAllModelElements().contains(merch3));
		assertTrue(ModelUtil.areEqual(getProject(), secondProject));
	}

	// END COMPLEX CODE

	@Test
	public void reverseSetOfUnsettedMultiContainmentReferenceTest() {
		final Fan fan = BowlingFactory.eINSTANCE.createFan();
		final Merchandise merch1 = BowlingFactory.eINSTANCE.createMerchandise();
		final Merchandise merch2 = BowlingFactory.eINSTANCE.createMerchandise();
		final Merchandise merch3 = BowlingFactory.eINSTANCE.createMerchandise();
		merch1.setName(M1);
		merch2.setName(M2);
		merch3.setName(M3);

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				getProject().addModelElement(fan);
				getProject().addModelElement(merch1);
				getProject().addModelElement(merch2);
				getProject().addModelElement(merch3);
				assertEquals(0, fan.getFanMerchandise().size());
				assertFalse(fan.isSetFanMerchandise());
			}
		}.run(false);

		clearOperations();
		final Project secondProject = ModelUtil.clone(getProject());

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				fan.getFanMerchandise().add(merch1);
				fan.getFanMerchandise().add(merch2);
				fan.getFanMerchandise().add(merch3);
				assertEquals(3, fan.getFanMerchandise().size());
				assertTrue(fan.isSetFanMerchandise());
			}
		}.run(false);

		final List<AbstractOperation> operations = forceGetOperations();

		assertEquals(3, operations.size());

		final AbstractOperation operation = operations.get(0);
		assertTrue(operation instanceof MultiReferenceOperation);
		final MultiReferenceOperation mrop1 = (MultiReferenceOperation) operation;

		final AbstractOperation operation2 = operations.get(1);
		assertTrue(operation2 instanceof MultiReferenceOperation);
		final MultiReferenceOperation mrop2 = (MultiReferenceOperation) operation2;

		final AbstractOperation operation3 = operations.get(2);
		assertTrue(operation3 instanceof MultiReferenceOperation);
		final MultiReferenceOperation mrop3 = (MultiReferenceOperation) operation3;

		final ModelElementId fanId = ModelUtil.getProject(fan).getModelElementId(fan);
		assertEquals(fanId, mrop1.getModelElementId());
		assertEquals(fanId, mrop2.getModelElementId());
		assertEquals(fanId, mrop3.getModelElementId());

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				mrop3.reverse().apply(getProject());
				mrop2.reverse().apply(getProject());
				mrop1.reverse().apply(getProject());
			}
		}.run(false);

		assertEquals(0, fan.getFanMerchandise().size());
		assertTrue(!fan.isSetFanMerchandise());
		assertEquals(secondProject.getModelElements().size(), getProject().getModelElements().size());
		assertTrue(ModelUtil.areEqual(getProject(), secondProject));
	}

	@Test
	public void setUnsetMultiReferenceToEmpty() {
		final Fan fan = BowlingFactory.eINSTANCE.createFan();

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				getProject().addModelElement(fan);
				assertEquals(0, fan.getVisitedTournaments().size());
				assertTrue(!fan.isSetVisitedTournaments());
			}
		}.run(false);

		clearOperations();
		final Project secondProject = ModelUtil.clone(getProject());

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				fan.getVisitedTournaments().clear();
				assertEquals(0, fan.getVisitedTournaments().size());
				assertTrue(fan.isSetVisitedTournaments());
			}
		}.run(false);

		final List<AbstractOperation> operations = forceGetOperations();

		assertEquals(1, operations.size());
		final AbstractOperation operation = operations.get(0);
		assertTrue(operation instanceof MultiReferenceOperation);
		final MultiReferenceOperation multRefOp = (MultiReferenceOperation) operation;

		new EMFStoreCommand() {
			@Override
			protected void doRun() {
				multRefOp.apply(secondProject);
			}
		}.run(false);

		assertTrue(ModelUtil.areEqual(getProject(), secondProject));
	}
}