org.eclipse.gmf.tests.runtime.emf.type.core/src/org/eclipse/gmf/tests/runtime/emf/type/core/commands/DestroyElementCommandTest.java - gmf-runtime/org.eclipse.gmf-runtime - Git at Google

 /******************************************************************************
  * Copyright (c) 2005, 2006 IBM Corporation 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:
  *    IBM Corporation - initial API and implementation
  ****************************************************************************/
 package org.eclipse.gmf.tests.runtime.emf.type.core.commands;

 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;

 import junit.framework.Test;
 import junit.framework.TestSuite;

 import org.eclipse.emf.common.util.URI;
 import org.eclipse.emf.ecore.EAnnotation;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.EReference;
 import org.eclipse.emf.ecore.EcoreFactory;
 import org.eclipse.emf.ecore.change.ChangeDescription;
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.emf.transaction.RecordingCommand;
 import org.eclipse.gmf.runtime.common.core.command.ICommand;
 import org.eclipse.gmf.runtime.common.core.command.ICompositeCommand;
 import org.eclipse.gmf.runtime.emf.type.core.ElementTypeRegistry;
 import org.eclipse.gmf.runtime.emf.type.core.IElementType;
 import org.eclipse.gmf.runtime.emf.type.core.commands.DestroyElementCommand;
 import org.eclipse.gmf.runtime.emf.type.core.requests.DestroyDependentsRequest;
 import org.eclipse.gmf.runtime.emf.type.core.requests.DestroyElementRequest;
 import org.eclipse.gmf.tests.runtime.emf.type.core.AbstractEMFTypeTest;
 import org.eclipse.gmf.tests.runtime.emf.type.core.employee.Client;
 import org.eclipse.gmf.tests.runtime.emf.type.core.employee.Customer;
 import org.eclipse.gmf.tests.runtime.emf.type.core.employee.EmployeeFactory;
 import org.eclipse.gmf.tests.runtime.emf.type.core.internal.ClientDependentsAdvice;
 import org.eclipse.gmf.tests.runtime.emf.type.core.internal.DestroyCustomerAdvice;

 /**
  * Tests the extensible {@link DestroyElementCommand}.
  *
  * @author Christian W. Damus (cdamus)
  */
 public class DestroyElementCommandTest
     extends AbstractEMFTypeTest {

 	static final String ANNOTATION_SOURCE = "org.eclipse.gmf.tests.runtime.emf.type.core"; //$NON-NLS-1$

     private Customer parentCompany;
     private Customer customer;
     private Client billieJo;
     private Client jimBob;

     private EAnnotation billieJoAnnotation;
     private EAnnotation jimBobAnnotation;

     public DestroyElementCommandTest(String name) {
         super(name);
     }

     public static Test suite() {
         return new TestSuite(DestroyElementCommandTest.class, "DestroyElementCommand Tests"); //$NON-NLS-1$
     }

     /**
      * Tests just the functionality of the destroy command, itself.
      */
     public void test_destroyCommand_basic() {
     	DestroyElementCommand cmd = new DestroyElementCommand(
     			new DestroyElementRequest(billieJo, false));

     	execute(cmd);

     	assertDestroyed(billieJo);

     	// annotation was not destroyed
     	assertSame(billieJoAnnotation.eContainer(), customer);

     	// but reference to Billie Jo was cleared
     	assertEquals(0, billieJoAnnotation.getReferences().size());

     	undo(cmd);

     	assertSame(customer, billieJo.eContainer());
     	assertSame(billieJoAnnotation.eContainer(), customer);
     	assertTrue(billieJoAnnotation.getReferences().contains(billieJo));

     	redo(cmd);

     	assertDestroyed(billieJo);
     	assertSame(billieJoAnnotation.eContainer(), customer);
     	assertEquals(0, billieJoAnnotation.getReferences().size());
    }

     /**
      * Tests that we cannot destroy detached elements.
      */
     public void test_destroyCommand_detached() {
     	Client detachedClient = getEmployeeFactory().createClient();

     	DestroyElementRequest req = new DestroyElementRequest(detachedClient, false);

     	assertNull(req.getEditHelperContext());

     	DestroyElementCommand cmd = new DestroyElementCommand(req);

     	assertFalse(cmd.canExecute());
    }

     /**
      * Tests that dependents are correctly destroyed, as well.
      */
     public void test_destroyCommand_withDependents() {
     	DestroyElementRequest req = new DestroyElementRequest(billieJo, false);
     	IElementType type = ElementTypeRegistry.getInstance().getElementType(
     			req.getEditHelperContext());

     	assertNotNull(type);

     	ICommand cmd = type.getEditCommand(req);

     	assertNotNull(cmd);
     	assertNoDuplicates(cmd);

     	execute(cmd);

     	assertDestroyed(billieJo);
     	assertDestroyed(billieJoAnnotation);

     	undo(cmd);

     	assertSame(customer, billieJo.eContainer());
     	assertSame(billieJoAnnotation.eContainer(), customer);
     	assertTrue(billieJoAnnotation.getReferences().contains(billieJo));

     	redo(cmd);

     	assertDestroyed(billieJo);
     	assertDestroyed(billieJoAnnotation);
    }

     /**
      * Tests that all contents (recursively) are correctly destroyed, as well.
      * Incidentally tests the destruction of resource roots.
      */
     public void test_destroyCommand_withContainment() {
     	// destroy the parent company (resource root)
     	DestroyElementRequest req = new DestroyElementRequest(parentCompany, false);
     	IElementType type = ElementTypeRegistry.getInstance().getElementType(
     			req.getEditHelperContext());

     	assertNotNull(type);

     	ICommand cmd = type.getEditCommand(req);

     	assertNotNull(cmd);
     	assertNoDuplicates(cmd);

     	execute(cmd);

     	assertDestroyed(parentCompany);
     	assertDestroyed(customer);
     	assertDestroyed(billieJo);
     	assertDestroyed(billieJoAnnotation);
     	assertDestroyed(jimBob);
     	assertDestroyed(jimBobAnnotation);

     	undo(cmd);

     	assertSame(getResource(), parentCompany.eResource());
     	assertSame(parentCompany, customer.eContainer());
     	assertSame(customer, billieJo.eContainer());
     	assertSame(billieJoAnnotation.eContainer(), customer);
     	assertTrue(billieJoAnnotation.getReferences().contains(billieJo));
     	assertSame(customer, jimBob.eContainer());
     	assertSame(jimBobAnnotation.eContainer(), customer);
     	assertTrue(jimBobAnnotation.getReferences().contains(jimBob));

     	redo(cmd);

     	assertDestroyed(parentCompany);
     	assertDestroyed(customer);
     	assertDestroyed(billieJo);
     	assertDestroyed(billieJoAnnotation);
     	assertDestroyed(jimBob);
     	assertDestroyed(jimBobAnnotation);
     }

     /**
 	 * Tests that we completely destroy cross-resource-contained objects, also
 	 * (removing them from their resource).
 	 */
     public void test_destroy_crossResourceContained_136738() {
     	// use the Ecore metamodel because EXTLibrary does not have any
     	//    cross-resource containment support

     	// create a couple of resources
     	final Resource res1 = getEditingDomain().getResourceSet().createResource(
     			URI.createURI("null://res1.ecore")); //$NON-NLS-1$
     	final Resource res2 = getEditingDomain().getResourceSet().createResource(
     			URI.createURI("null://res2.ecore")); //$NON-NLS-1$

     	// the Ecore model
     	final EPackage pkg1 = EcoreFactory.eINSTANCE.createEPackage();
     	pkg1.setName("package1"); //$NON-NLS-1$
     	final EClass class1 = EcoreFactory.eINSTANCE.createEClass();
     	class1.setName("Class1"); //$NON-NLS-1$
     	final EClass class2 = EcoreFactory.eINSTANCE.createEClass();
     	class2.setName("Class2"); //$NON-NLS-1$

     	// establish cross-resource containment
         RecordingCommand command = new RecordingCommand(getEditingDomain()) {
             protected void doExecute() {
                 res1.getContents().add(pkg1);
                 pkg1.getEClassifiers().add(class1);
                 pkg1.getEClassifiers().add(class2);
                 class2.getESuperTypes().add(class1);  // set a reference feature

                 res2.getContents().add(class2);
             }};
         getEditingDomain().getCommandStack().execute(command);

         // check that we have cross-resource containment
         assertSame(pkg1, class2.eContainer());
         assertSame(res2, class2.eResource());

     	DestroyElementRequest req = new DestroyElementRequest(class2, false);
     	IElementType type = ElementTypeRegistry.getInstance().getElementType(
     			req.getEditHelperContext());

     	assertNotNull(type);

     	ICommand cmd = type.getEditCommand(req);

     	assertNotNull(cmd);
     	assertNoDuplicates(cmd);

     	execute(cmd);

     	assertDestroyed(class2);
     	assertNull(class2.eResource());

     	undo(cmd);

     	assertSame(pkg1, class2.eContainer());
     	assertSame(res2, class2.eResource());
     	assertTrue(class2.getESuperTypes().contains(class1));  // check the reference

     	redo(cmd);

     	assertDestroyed(class2);
     	assertNull(class2.eResource());
    }

     /**
 	 * Tests that the element to destroy in a DestroyRequest is the same in the
 	 * before advice as it is in the after advice.
 	 */
     public void test_preserveElementToDestroy_142561() {

 		DestroyElementRequest req = new DestroyElementRequest(parentCompany,
 				false);
 		IElementType type = ElementTypeRegistry.getInstance().getElementType(
 				req.getEditHelperContext());

 		req.setParameter(DestroyCustomerAdvice.BEFORE, new ArrayList());
 		req.setParameter(DestroyCustomerAdvice.AFTER, new ArrayList());

 		assertNotNull(type);

 		ICommand cmd = type.getEditCommand(req);

 		assertNotNull(cmd);
 		assertNoDuplicates(cmd);

 		execute(cmd);

 		assertDestroyed(parentCompany);

 		// verify that the after advice sees the same elements to destroy in the reverse order
 		List before = (List) req.getParameter(DestroyCustomerAdvice.BEFORE);
 		List after = (List) req.getParameter(DestroyCustomerAdvice.AFTER);

 		Collections.reverse(after);
 		assertEquals(before, after);
 	}

     /**
 	 * Verifies the advice on the DestroyDependentsRequest (e.g.,
 	 * ClientDependentsAdvice) can access the initial element that was requested
 	 * to be destroyed.
 	 */
     public void test_initialElementToBeDestroyed_146559() {
     	DestroyElementRequest req = new DestroyElementRequest(parentCompany,
 				false);
 		IElementType type = ElementTypeRegistry.getInstance().getElementType(
 				req.getEditHelperContext());

 		assertNotNull(type);

 		ICommand cmd = type.getEditCommand(req);

 		assertNotNull(cmd);
 		assertNoDuplicates(cmd);

 		execute(cmd);

 		assertDestroyed(parentCompany);

 		// verify that the dependents advice sees the same initial element to destroy
 		DestroyDependentsRequest dependentsRequest = (DestroyDependentsRequest) req
 				.getParameter(DestroyElementRequest.DESTROY_DEPENDENTS_REQUEST_PARAMETER);
 		Object initial = dependentsRequest
 				.getParameter(ClientDependentsAdvice.INITIAL);

 		assertEquals(parentCompany, initial);
     }

     //
     // Test framework methods
     //

     protected void doModelSetup(Resource resource) {
         parentCompany = getEmployeeFactory().createCustomer();
         parentCompany.setName("GlobalMega"); //$NON-NLS-1$
         resource.getContents().add(parentCompany);

         customer = getEmployeeFactory().createCustomer();
         customer.setName("Acme"); //$NON-NLS-1$
         parentCompany.getSubsidiaries().add(customer);

         billieJo = createClient("Billie Jo", "Swanson", customer); //$NON-NLS-1$ //$NON-NLS-2$
         billieJoAnnotation = createAnnotation(billieJo);
         jimBob = createClient("Jim Bob", "Jones", customer); //$NON-NLS-1$ //$NON-NLS-2$
         jimBobAnnotation = createAnnotation(jimBob);
     }

     protected Client createClient(String firstName, String lastName, Customer _customer) {
     	Client result = EmployeeFactory.eINSTANCE.createClient();
         result.setFirstName(firstName);
         result.setLastName(lastName);
         _customer.getRepresentatives().add(result);

         return result;
     }

     protected EAnnotation createAnnotation(Client client) {
     	EAnnotation result = EcoreFactory.eINSTANCE.createEAnnotation();

     	result.setSource(ANNOTATION_SOURCE);
     	result.getReferences().add(client);
     	client.getRepresents().getEAnnotations().add(result);

     	return result;
     }

     protected void assertDestroyed(EObject eObject) {
     	assertTrue((eObject.eContainer() == null)
     			|| (eObject.eContainer() instanceof ChangeDescription));

     	// no references exist to any other object.  Note that there should not
     	//    be a container reference of type ChangeDescription  :-)
     	for (Iterator iter = eObject.eClass().getEAllReferences().iterator(); iter.hasNext();) {
     		EReference next = (EReference) iter.next();

     		assertFalse(eObject.eIsSet(next));
     	}

     	// in case it was a root object
     	assertFalse(getResource().getContents().contains(eObject));
     }

     /**
 	 * Tests that there are no duplicate commands to destroy the same element in
 	 * <code>cmd</code>. Used to verify Bugzilla 145763.
 	 *
 	 * @param cmd
 	 *            the command to test
 	 */
 	private void assertNoDuplicates(ICommand cmd) {
 		assertNoDuplicatesImpl(cmd, new ArrayList());
 	}

 	private void assertNoDuplicatesImpl(ICommand cmd, List toDestroy) {

 		if (cmd instanceof DestroyElementCommand) {
 			try {
 				Method getElementToDestroy = DestroyElementCommand.class
 						.getDeclaredMethod("getElementToDestroy", null); //$NON-NLS-1$
 				getElementToDestroy.setAccessible(true);
 				EObject element = (EObject) getElementToDestroy.invoke(
 						cmd, null);

 				if (toDestroy.contains(element)) {
 					fail("Duplicate destroy command for: " + element); //$NON-NLS-1$
 				}
 				toDestroy.add(element);
 			} catch (NoSuchMethodException nsme) {
 				fail("Unexpected exception: " + nsme); //$NON-NLS-1$
 			} catch (IllegalAccessException iae) {
 				fail("Unexpected exception: " + iae); //$NON-NLS-1$
 			} catch (InvocationTargetException ite) {
 				fail("Unexpected exception: " + ite); //$NON-NLS-1$
 			}

 		} else if (cmd instanceof ICompositeCommand) {
 			for (Iterator i = ((ICompositeCommand) cmd).iterator(); i.hasNext();) {
 				ICommand next = (ICommand) i.next();
 				assertNoDuplicatesImpl(next, toDestroy);
 			}
 		}
 	}
 }
	/******************************************************************************
	* Copyright (c) 2005, 2006 IBM Corporation 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:
	* IBM Corporation - initial API and implementation
	****************************************************************************/
	package org.eclipse.gmf.tests.runtime.emf.type.core.commands;

	import java.lang.reflect.InvocationTargetException;
	import java.lang.reflect.Method;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.Iterator;
	import java.util.List;

	import junit.framework.Test;
	import junit.framework.TestSuite;

	import org.eclipse.emf.common.util.URI;
	import org.eclipse.emf.ecore.EAnnotation;
	import org.eclipse.emf.ecore.EClass;
	import org.eclipse.emf.ecore.EObject;
	import org.eclipse.emf.ecore.EPackage;
	import org.eclipse.emf.ecore.EReference;
	import org.eclipse.emf.ecore.EcoreFactory;
	import org.eclipse.emf.ecore.change.ChangeDescription;
	import org.eclipse.emf.ecore.resource.Resource;
	import org.eclipse.emf.transaction.RecordingCommand;
	import org.eclipse.gmf.runtime.common.core.command.ICommand;
	import org.eclipse.gmf.runtime.common.core.command.ICompositeCommand;
	import org.eclipse.gmf.runtime.emf.type.core.ElementTypeRegistry;
	import org.eclipse.gmf.runtime.emf.type.core.IElementType;
	import org.eclipse.gmf.runtime.emf.type.core.commands.DestroyElementCommand;
	import org.eclipse.gmf.runtime.emf.type.core.requests.DestroyDependentsRequest;
	import org.eclipse.gmf.runtime.emf.type.core.requests.DestroyElementRequest;
	import org.eclipse.gmf.tests.runtime.emf.type.core.AbstractEMFTypeTest;
	import org.eclipse.gmf.tests.runtime.emf.type.core.employee.Client;
	import org.eclipse.gmf.tests.runtime.emf.type.core.employee.Customer;
	import org.eclipse.gmf.tests.runtime.emf.type.core.employee.EmployeeFactory;
	import org.eclipse.gmf.tests.runtime.emf.type.core.internal.ClientDependentsAdvice;
	import org.eclipse.gmf.tests.runtime.emf.type.core.internal.DestroyCustomerAdvice;

	/**
	* Tests the extensible {@link DestroyElementCommand}.
	*
	* @author Christian W. Damus (cdamus)
	*/
	public class DestroyElementCommandTest
	extends AbstractEMFTypeTest {

	static final String ANNOTATION_SOURCE = "org.eclipse.gmf.tests.runtime.emf.type.core"; //$NON-NLS-1$

	private Customer parentCompany;
	private Customer customer;
	private Client billieJo;
	private Client jimBob;

	private EAnnotation billieJoAnnotation;
	private EAnnotation jimBobAnnotation;

	public DestroyElementCommandTest(String name) {
	super(name);
	}

	public static Test suite() {
	return new TestSuite(DestroyElementCommandTest.class, "DestroyElementCommand Tests"); //$NON-NLS-1$
	}

	/**
	* Tests just the functionality of the destroy command, itself.
	*/
	public void test_destroyCommand_basic() {
	DestroyElementCommand cmd = new DestroyElementCommand(
	new DestroyElementRequest(billieJo, false));

	execute(cmd);

	assertDestroyed(billieJo);

	// annotation was not destroyed
	assertSame(billieJoAnnotation.eContainer(), customer);

	// but reference to Billie Jo was cleared
	assertEquals(0, billieJoAnnotation.getReferences().size());

	undo(cmd);

	assertSame(customer, billieJo.eContainer());
	assertSame(billieJoAnnotation.eContainer(), customer);
	assertTrue(billieJoAnnotation.getReferences().contains(billieJo));

	redo(cmd);

	assertDestroyed(billieJo);
	assertSame(billieJoAnnotation.eContainer(), customer);
	assertEquals(0, billieJoAnnotation.getReferences().size());
	}

	/**
	* Tests that we cannot destroy detached elements.
	*/
	public void test_destroyCommand_detached() {
	Client detachedClient = getEmployeeFactory().createClient();

	DestroyElementRequest req = new DestroyElementRequest(detachedClient, false);

	assertNull(req.getEditHelperContext());

	DestroyElementCommand cmd = new DestroyElementCommand(req);

	assertFalse(cmd.canExecute());
	}

	/**
	* Tests that dependents are correctly destroyed, as well.
	*/
	public void test_destroyCommand_withDependents() {
	DestroyElementRequest req = new DestroyElementRequest(billieJo, false);
	IElementType type = ElementTypeRegistry.getInstance().getElementType(
	req.getEditHelperContext());

	assertNotNull(type);

	ICommand cmd = type.getEditCommand(req);

	assertNotNull(cmd);
	assertNoDuplicates(cmd);

	execute(cmd);

	assertDestroyed(billieJo);
	assertDestroyed(billieJoAnnotation);

	undo(cmd);

	assertSame(customer, billieJo.eContainer());
	assertSame(billieJoAnnotation.eContainer(), customer);
	assertTrue(billieJoAnnotation.getReferences().contains(billieJo));

	redo(cmd);

	assertDestroyed(billieJo);
	assertDestroyed(billieJoAnnotation);
	}

	/**
	* Tests that all contents (recursively) are correctly destroyed, as well.
	* Incidentally tests the destruction of resource roots.
	*/
	public void test_destroyCommand_withContainment() {
	// destroy the parent company (resource root)
	DestroyElementRequest req = new DestroyElementRequest(parentCompany, false);
	IElementType type = ElementTypeRegistry.getInstance().getElementType(
	req.getEditHelperContext());

	assertNotNull(type);

	ICommand cmd = type.getEditCommand(req);

	assertNotNull(cmd);
	assertNoDuplicates(cmd);

	execute(cmd);

	assertDestroyed(parentCompany);
	assertDestroyed(customer);
	assertDestroyed(billieJo);
	assertDestroyed(billieJoAnnotation);
	assertDestroyed(jimBob);
	assertDestroyed(jimBobAnnotation);

	undo(cmd);

	assertSame(getResource(), parentCompany.eResource());
	assertSame(parentCompany, customer.eContainer());
	assertSame(customer, billieJo.eContainer());
	assertSame(billieJoAnnotation.eContainer(), customer);
	assertTrue(billieJoAnnotation.getReferences().contains(billieJo));
	assertSame(customer, jimBob.eContainer());
	assertSame(jimBobAnnotation.eContainer(), customer);
	assertTrue(jimBobAnnotation.getReferences().contains(jimBob));

	redo(cmd);

	assertDestroyed(parentCompany);
	assertDestroyed(customer);
	assertDestroyed(billieJo);
	assertDestroyed(billieJoAnnotation);
	assertDestroyed(jimBob);
	assertDestroyed(jimBobAnnotation);
	}

	/**
	* Tests that we completely destroy cross-resource-contained objects, also
	* (removing them from their resource).
	*/
	public void test_destroy_crossResourceContained_136738() {
	// use the Ecore metamodel because EXTLibrary does not have any
	// cross-resource containment support

	// create a couple of resources
	final Resource res1 = getEditingDomain().getResourceSet().createResource(
	URI.createURI("null://res1.ecore")); //$NON-NLS-1$
	final Resource res2 = getEditingDomain().getResourceSet().createResource(
	URI.createURI("null://res2.ecore")); //$NON-NLS-1$

	// the Ecore model
	final EPackage pkg1 = EcoreFactory.eINSTANCE.createEPackage();
	pkg1.setName("package1"); //$NON-NLS-1$
	final EClass class1 = EcoreFactory.eINSTANCE.createEClass();
	class1.setName("Class1"); //$NON-NLS-1$
	final EClass class2 = EcoreFactory.eINSTANCE.createEClass();
	class2.setName("Class2"); //$NON-NLS-1$

	// establish cross-resource containment
	RecordingCommand command = new RecordingCommand(getEditingDomain()) {
	protected void doExecute() {
	res1.getContents().add(pkg1);
	pkg1.getEClassifiers().add(class1);
	pkg1.getEClassifiers().add(class2);
	class2.getESuperTypes().add(class1); // set a reference feature

	res2.getContents().add(class2);
	}};
	getEditingDomain().getCommandStack().execute(command);

	// check that we have cross-resource containment
	assertSame(pkg1, class2.eContainer());
	assertSame(res2, class2.eResource());

	DestroyElementRequest req = new DestroyElementRequest(class2, false);
	IElementType type = ElementTypeRegistry.getInstance().getElementType(
	req.getEditHelperContext());

	assertNotNull(type);

	ICommand cmd = type.getEditCommand(req);

	assertNotNull(cmd);
	assertNoDuplicates(cmd);

	execute(cmd);

	assertDestroyed(class2);
	assertNull(class2.eResource());

	undo(cmd);

	assertSame(pkg1, class2.eContainer());
	assertSame(res2, class2.eResource());
	assertTrue(class2.getESuperTypes().contains(class1)); // check the reference

	redo(cmd);

	assertDestroyed(class2);
	assertNull(class2.eResource());
	}

	/**
	* Tests that the element to destroy in a DestroyRequest is the same in the
	* before advice as it is in the after advice.
	*/
	public void test_preserveElementToDestroy_142561() {

	DestroyElementRequest req = new DestroyElementRequest(parentCompany,
	false);
	IElementType type = ElementTypeRegistry.getInstance().getElementType(
	req.getEditHelperContext());

	req.setParameter(DestroyCustomerAdvice.BEFORE, new ArrayList());
	req.setParameter(DestroyCustomerAdvice.AFTER, new ArrayList());

	assertNotNull(type);

	ICommand cmd = type.getEditCommand(req);

	assertNotNull(cmd);
	assertNoDuplicates(cmd);

	execute(cmd);

	assertDestroyed(parentCompany);

	// verify that the after advice sees the same elements to destroy in the reverse order
	List before = (List) req.getParameter(DestroyCustomerAdvice.BEFORE);
	List after = (List) req.getParameter(DestroyCustomerAdvice.AFTER);

	Collections.reverse(after);
	assertEquals(before, after);
	}

	/**
	* Verifies the advice on the DestroyDependentsRequest (e.g.,
	* ClientDependentsAdvice) can access the initial element that was requested
	* to be destroyed.
	*/
	public void test_initialElementToBeDestroyed_146559() {
	DestroyElementRequest req = new DestroyElementRequest(parentCompany,
	false);
	IElementType type = ElementTypeRegistry.getInstance().getElementType(
	req.getEditHelperContext());

	assertNotNull(type);

	ICommand cmd = type.getEditCommand(req);

	assertNotNull(cmd);
	assertNoDuplicates(cmd);

	execute(cmd);

	assertDestroyed(parentCompany);

	// verify that the dependents advice sees the same initial element to destroy
	DestroyDependentsRequest dependentsRequest = (DestroyDependentsRequest) req
	.getParameter(DestroyElementRequest.DESTROY_DEPENDENTS_REQUEST_PARAMETER);
	Object initial = dependentsRequest
	.getParameter(ClientDependentsAdvice.INITIAL);

	assertEquals(parentCompany, initial);
	}

	//
	// Test framework methods
	//

	protected void doModelSetup(Resource resource) {
	parentCompany = getEmployeeFactory().createCustomer();
	parentCompany.setName("GlobalMega"); //$NON-NLS-1$
	resource.getContents().add(parentCompany);

	customer = getEmployeeFactory().createCustomer();
	customer.setName("Acme"); //$NON-NLS-1$
	parentCompany.getSubsidiaries().add(customer);

	billieJo = createClient("Billie Jo", "Swanson", customer); //$NON-NLS-1$ //$NON-NLS-2$
	billieJoAnnotation = createAnnotation(billieJo);
	jimBob = createClient("Jim Bob", "Jones", customer); //$NON-NLS-1$ //$NON-NLS-2$
	jimBobAnnotation = createAnnotation(jimBob);
	}

	protected Client createClient(String firstName, String lastName, Customer _customer) {
	Client result = EmployeeFactory.eINSTANCE.createClient();
	result.setFirstName(firstName);
	result.setLastName(lastName);
	_customer.getRepresentatives().add(result);

	return result;
	}

	protected EAnnotation createAnnotation(Client client) {
	EAnnotation result = EcoreFactory.eINSTANCE.createEAnnotation();

	result.setSource(ANNOTATION_SOURCE);
	result.getReferences().add(client);
	client.getRepresents().getEAnnotations().add(result);

	return result;
	}

	protected void assertDestroyed(EObject eObject) {
	assertTrue((eObject.eContainer() == null)
	\|\| (eObject.eContainer() instanceof ChangeDescription));

	// no references exist to any other object. Note that there should not
	// be a container reference of type ChangeDescription :-)
	for (Iterator iter = eObject.eClass().getEAllReferences().iterator(); iter.hasNext();) {
	EReference next = (EReference) iter.next();

	assertFalse(eObject.eIsSet(next));
	}

	// in case it was a root object
	assertFalse(getResource().getContents().contains(eObject));
	}

	/**
	* Tests that there are no duplicate commands to destroy the same element in
	* <code>cmd</code>. Used to verify Bugzilla 145763.
	*
	* @param cmd
	* the command to test
	*/
	private void assertNoDuplicates(ICommand cmd) {
	assertNoDuplicatesImpl(cmd, new ArrayList());
	}

	private void assertNoDuplicatesImpl(ICommand cmd, List toDestroy) {

	if (cmd instanceof DestroyElementCommand) {
	try {
	Method getElementToDestroy = DestroyElementCommand.class
	.getDeclaredMethod("getElementToDestroy", null); //$NON-NLS-1$
	getElementToDestroy.setAccessible(true);
	EObject element = (EObject) getElementToDestroy.invoke(
	cmd, null);

	if (toDestroy.contains(element)) {
	fail("Duplicate destroy command for: " + element); //$NON-NLS-1$
	}
	toDestroy.add(element);
	} catch (NoSuchMethodException nsme) {
	fail("Unexpected exception: " + nsme); //$NON-NLS-1$
	} catch (IllegalAccessException iae) {
	fail("Unexpected exception: " + iae); //$NON-NLS-1$
	} catch (InvocationTargetException ite) {
	fail("Unexpected exception: " + ite); //$NON-NLS-1$
	}

	} else if (cmd instanceof ICompositeCommand) {
	for (Iterator i = ((ICompositeCommand) cmd).iterator(); i.hasNext();) {
	ICommand next = (ICommand) i.next();
	assertNoDuplicatesImpl(next, toDestroy);
	}
	}
	}
	}