tests/org.eclipse.emfforms.editor.ecore.test/src/org/eclipse/emfforms/spi/editor/EcoreReferenceServiceCustomizationProviders_ITest.java - emfclient/org.eclipse.emf.ecp.core - Git at Google

 /*******************************************************************************
  * Copyright (c) 2018 Christian W. Damus and others.
  *
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  * Christian W. Damus - initial API and implementation
  ******************************************************************************/
 package org.eclipse.emfforms.spi.editor;

 import static java.util.Collections.singleton;
 import static org.hamcrest.CoreMatchers.everyItem;
 import static org.hamcrest.CoreMatchers.hasItem;
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.CoreMatchers.not;
 import static org.hamcrest.CoreMatchers.notNullValue;
 import static org.hamcrest.MatcherAssert.assertThat;

 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 import java.lang.reflect.Method;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Set;

 import org.eclipse.emf.common.command.BasicCommandStack;
 import org.eclipse.emf.common.util.URI;
 import org.eclipse.emf.ecore.EAnnotation;
 import org.eclipse.emf.ecore.EAttribute;
 import org.eclipse.emf.ecore.EClass;
 import org.eclipse.emf.ecore.EClassifier;
 import org.eclipse.emf.ecore.EDataType;
 import org.eclipse.emf.ecore.ENamedElement;
 import org.eclipse.emf.ecore.EObject;
 import org.eclipse.emf.ecore.EPackage;
 import org.eclipse.emf.ecore.EReference;
 import org.eclipse.emf.ecore.EStructuralFeature;
 import org.eclipse.emf.ecore.EcoreFactory;
 import org.eclipse.emf.ecore.EcorePackage;
 import org.eclipse.emf.ecore.change.ChangeDescription;
 import org.eclipse.emf.ecore.change.ChangeFactory;
 import org.eclipse.emf.ecore.resource.Resource;
 import org.eclipse.emf.ecore.resource.ResourceSet;
 import org.eclipse.emf.ecp.ui.view.swt.reference.AttachmentStrategy;
 import org.eclipse.emf.ecp.ui.view.swt.reference.EObjectSelectionStrategy;
 import org.eclipse.emf.ecp.ui.view.swt.reference.OpenInNewContextStrategy;
 import org.eclipse.emf.ecp.ui.view.swt.reference.ReferenceStrategy;
 import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
 import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
 import org.eclipse.emfforms.bazaar.Bazaar;
 import org.eclipse.emfforms.bazaar.BazaarContext;
 import org.eclipse.emfforms.bazaar.Vendor;
 import org.eclipse.emfforms.internal.editor.ecore.referenceservices.EcoreAttachmentStrategyProvider;
 import org.eclipse.emfforms.internal.editor.ecore.referenceservices.EcoreEObjectSelectionStrategyProvider;
 import org.eclipse.emfforms.internal.editor.ecore.referenceservices.EcoreOpenInNewContextStrategyProvider;
 import org.eclipse.emfforms.internal.editor.ecore.referenceservices.EcoreReferenceStrategyProvider;
 import org.eclipse.jface.dialogs.Dialog;
 import org.eclipse.jface.dialogs.IDialogConstants;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.widgets.Composite;
 import org.eclipse.swt.widgets.Control;
 import org.eclipse.swt.widgets.Display;
 import org.eclipse.swt.widgets.Event;
 import org.eclipse.swt.widgets.Item;
 import org.eclipse.swt.widgets.Shell;
 import org.eclipse.swt.widgets.Table;
 import org.eclipse.swt.widgets.Tree;
 import org.eclipse.swt.widgets.Widget;
 import org.hamcrest.CoreMatchers;
 import org.junit.After;
 import org.junit.Assume;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.TestRule;
 import org.junit.runner.Description;
 import org.junit.runners.model.Statement;
 import org.osgi.framework.InvalidSyntaxException;

 /**
  * Integration test cases for the Ecore Editor's reference service strategy provider classes.
  */
 @SuppressWarnings({ "nls", "restriction" })
 public class EcoreReferenceServiceCustomizationProviders_ITest {

 	@Rule
 	public final BazaarRule bazaar = new BazaarRule();

 	private EPackage testPackage;

 	/**
 	 * Initializes me.
 	 */
 	public EcoreReferenceServiceCustomizationProviders_ITest() {
 		super();
 	}

 	@ProviderType(EcoreReferenceStrategyProvider.class)
 	@Test
 	public void setEOppositeReference() throws InvalidSyntaxException {
 		final EClass foo = (EClass) testPackage.getEClassifier("Foo");
 		final EClass abstrakt = (EClass) testPackage.getEClassifier("Abstract");
 		final EReference ref = (EReference) foo.getEStructuralFeature("ref");
 		final EReference opposite = EcoreFactory.eINSTANCE.createEReference();
 		abstrakt.getEStructuralFeatures().add(opposite);

 		final ReferenceStrategy strategy = bazaar.getStrategy(foo, EcorePackage.Literals.EREFERENCE__EOPPOSITE);

 		strategy.addElementsToReference(ref, EcorePackage.Literals.EREFERENCE__EOPPOSITE, singleton(opposite));

 		assertThat("Reference's opposite not set", ref.getEOpposite(), is(opposite));
 		assertThat("Opposite's opposite not set", opposite.getEOpposite(), is(ref));
 		assertThat("Opposite's type not set", opposite.getEReferenceType(), is(foo));
 		assertThat("Reference's type not set", ref.getEReferenceType(), is(abstrakt));
 	}

 	@ProviderType(EcoreAttachmentStrategyProvider.class)
 	@Test
 	public void attachOppositeReference() {
 		final EClass foo = (EClass) testPackage.getEClassifier("Foo");
 		final EClass abstrakt = (EClass) testPackage.getEClassifier("Abstract");
 		final EReference ref = (EReference) foo.getEStructuralFeature("ref");
 		ref.setEType(abstrakt);
 		final EReference opposite = EcoreFactory.eINSTANCE.createEReference();

 		final AttachmentStrategy strategy = bazaar.getStrategy(foo, EcorePackage.Literals.EREFERENCE__EOPPOSITE);

 		strategy.addElementToModel(ref, EcorePackage.Literals.EREFERENCE__EOPPOSITE, opposite);

 		assertThat("Opposite not added to its owner", opposite.getEContainingClass(), is(abstrakt));
 		assertThat("Opposite's opposite not set", opposite.getEOpposite(), is(ref));
 		assertThat("Opposite's type not set", opposite.getEReferenceType(), is(foo));
 		assertThat("Opposite's name not set", opposite.getName(), notNullValue());
 	}

 	@ProviderType(EcoreEObjectSelectionStrategyProvider.class)
 	@Test
 	public void selectExistingEOpposite_refUntyped() {
 		final EClass foo = (EClass) testPackage.getEClassifier("Foo");
 		final EClass abstrakt = (EClass) testPackage.getEClassifier("Abstract");
 		final EReference ref = (EReference) foo.getEStructuralFeature("ref");
 		final EReference other = EcoreFactory.eINSTANCE.createEReference();
 		other.setName("other");
 		other.setEType(foo);
 		foo.getEStructuralFeatures().add(other);
 		final EReference opposite = EcoreFactory.eINSTANCE.createEReference();
 		abstrakt.getEStructuralFeatures().add(opposite);

 		final EObjectSelectionStrategy strategy = bazaar.getStrategy(foo, EcorePackage.Literals.EREFERENCE__EOPPOSITE);

 		Collection<EObject> selection = everything();
 		selection = strategy.collectExistingObjects(ref, EcorePackage.Literals.EREFERENCE__EOPPOSITE, selection);

 		assertThat(selection, everyItem(CoreMatchers.<EObject> instanceOf(EReference.class)));
 		assertThat(selection, hasItem(opposite));
 		assertThat(selection, not(hasItem(ref)));
 		assertThat(selection, hasItem(other)); // Could be an opposite, in theory
 	}

 	@ProviderType(EcoreEObjectSelectionStrategyProvider.class)
 	@Test
 	public void selectExistingEOpposite_refHasType() {
 		final EClass foo = (EClass) testPackage.getEClassifier("Foo");
 		final EClass abstrakt = (EClass) testPackage.getEClassifier("Abstract");
 		final EReference ref = (EReference) foo.getEStructuralFeature("ref");
 		final EReference other = EcoreFactory.eINSTANCE.createEReference();
 		other.setName("other");
 		other.setEType(foo);
 		foo.getEStructuralFeatures().add(other);
 		ref.setEType(abstrakt); // This determines the type that may contain opposites
 		final EReference opposite = EcoreFactory.eINSTANCE.createEReference();
 		abstrakt.getEStructuralFeatures().add(opposite);

 		final EObjectSelectionStrategy strategy = bazaar.getStrategy(foo, EcorePackage.Literals.EREFERENCE__EOPPOSITE);

 		Collection<EObject> selection = everything();
 		selection = strategy.collectExistingObjects(ref, EcorePackage.Literals.EREFERENCE__EOPPOSITE, selection);

 		assertThat(selection, everyItem(CoreMatchers.<EObject> instanceOf(EReference.class)));
 		assertThat(selection, hasItem(opposite));
 		assertThat(selection, not(hasItem(ref)));
 		assertThat(selection, not(hasItem(other))); // Not in the ref's type
 	}

 	@ProviderType(EcoreEObjectSelectionStrategyProvider.class)
 	@Test
 	public void selectExistingSupertype() {
 		final EClass foo = (EClass) testPackage.getEClassifier("Foo");
 		final EClass abstrakt = (EClass) testPackage.getEClassifier("Abstract");
 		final EClass subclass = EcoreFactory.eINSTANCE.createEClass();
 		subclass.setName("Subtype");
 		subclass.getESuperTypes().add(foo);
 		testPackage.getEClassifiers().add(subclass);

 		final EObjectSelectionStrategy strategy = bazaar.getStrategy(foo, EcorePackage.Literals.ECLASS__ESUPER_TYPES);

 		Collection<EObject> selection = everything();
 		selection = strategy.collectExistingObjects(foo, EcorePackage.Literals.ECLASS__ESUPER_TYPES, selection);

 		assertThat(selection, everyItem(CoreMatchers.<EObject> instanceOf(EClass.class)));
 		assertThat(selection, hasItem(abstrakt));
 		assertThat(selection, not(hasItem(subclass))); // Would cause cycle
 	}

 	@ProviderType(EcoreEObjectSelectionStrategyProvider.class)
 	@Test
 	public void selectExistingAttributeType() {
 		final EClass foo = (EClass) testPackage.getEClassifier("Foo");
 		final EClassifier intType = testPackage.getEClassifier("int");
 		final EStructuralFeature attr = foo.getEStructuralFeature("attr");

 		final EObjectSelectionStrategy strategy = bazaar.getStrategy(attr, EcorePackage.Literals.ETYPED_ELEMENT__ETYPE);

 		Collection<EObject> selection = everything();
 		selection = strategy.collectExistingObjects(attr, EcorePackage.Literals.ETYPED_ELEMENT__ETYPE, selection);

 		assertThat(selection, everyItem(CoreMatchers.<EObject> instanceOf(EDataType.class)));
 		assertThat(selection, hasItem(intType));
 	}

 	@ProviderType(EcoreEObjectSelectionStrategyProvider.class)
 	@Test
 	public void selectExistingAnnotationReference() {
 		final EClass foo = (EClass) testPackage.getEClassifier("Foo");
 		final EClassifier intType = testPackage.getEClassifier("int");
 		final EAnnotation annotation = EcoreFactory.eINSTANCE.createEAnnotation();
 		annotation.setSource("test");
 		foo.getEAnnotations().add(annotation);
 		final EObjectSelectionStrategy strategy = bazaar.getStrategy(annotation,
 			EcorePackage.Literals.EANNOTATION__REFERENCES);

 		final ChangeDescription change = ChangeFactory.eINSTANCE.createChangeDescription();
 		foo.eResource().getContents().add(change);

 		Collection<EObject> selection = everything();
 		Assume.assumeThat(selection, hasItem(change));
 		selection = strategy.collectExistingObjects(annotation, EcorePackage.Literals.EANNOTATION__REFERENCES,
 			selection);

 		assertThat(selection, everyItem(CoreMatchers.<EObject> instanceOf(ENamedElement.class)));
 		assertThat(selection, hasItem(intType));
 		assertThat(selection, not(hasItem(change)));
 	}

 	@ProviderType(EcoreOpenInNewContextStrategyProvider.class)
 	@Test
 	public void openInNewContext() {
 		final EClassifier foo = testPackage.getEClassifier("Foo");
 		final OpenInNewContextStrategy strategy = bazaar.getStrategy(foo, foo.eContainmentFeature());
 		assertThat(strategy, notNullValue());

 		final Set<Shell> expectedShells = new HashSet<Shell>(Arrays.asList(Display.getCurrent().getShells()));

 		// If a dialog appears close it
 		final boolean[] doIt = { true };
 		final boolean[] sawDialog = { false };
 		Display.getDefault().asyncExec(new Runnable() {

 			@Override
 			public void run() {
 				if (!doIt[0]) {
 					return;
 				}

 				for (final Shell next : Display.getCurrent().getShells()) {
 					if (!expectedShells.contains(next)) {
 						sawDialog[0] = true;
 						next.close();
 					}
 				}
 			}
 		});

 		strategy.openInNewContext(foo.eContainer(), foo.eContainmentFeature(), foo);

 		// If the dialog didn't appear, don't try anything after the test suite has moved on
 		doIt[0] = false;

 		assertThat("Open strategy presented a dialog", sawDialog[0], is(false));
 	}

 	//
 	// Test framework
 	//

 	@Before
 	public void createFixture() {
 		final AdapterFactoryEditingDomain domain = new AdapterFactoryEditingDomain(
 			new ComposedAdapterFactory(ComposedAdapterFactory.Descriptor.Registry.INSTANCE),
 			new BasicCommandStack());

 		testPackage = createTestPackage();
 		createResource(domain.getResourceSet(), testPackage);
 	}

 	@After
 	public void destroyFixture() {
 		testPackage = null;
 	}

 	EPackage createTestPackage() {
 		final EPackage result = createPackage("test");
 		final EClass foo = EcoreFactory.eINSTANCE.createEClass();
 		foo.setName("Foo");
 		result.getEClassifiers().add(foo);
 		final EAttribute state = EcoreFactory.eINSTANCE.createEAttribute();
 		state.setName("attr");
 		foo.getEStructuralFeatures().add(state);
 		final EReference ref = EcoreFactory.eINSTANCE.createEReference();
 		ref.setName("ref");
 		foo.getEStructuralFeatures().add(ref);
 		final EClass abstrakt = EcoreFactory.eINSTANCE.createEClass();
 		abstrakt.setAbstract(true);
 		abstrakt.setName("Abstract");
 		result.getEClassifiers().add(abstrakt);
 		final EDataType intType = EcoreFactory.eINSTANCE.createEDataType();
 		intType.setName("int");
 		intType.setInstanceTypeName("int");
 		result.getEClassifiers().add(intType);
 		return result;
 	}

 	void createResource(ResourceSet rset, EPackage ePackage) {
 		final Resource resource = rset.createResource(URI.createURI(ePackage.getNsURI()).appendFileExtension("ecore"));
 		resource.getContents().add(ePackage);
 	}

 	EPackage createPackage(String name) {
 		final EPackage result = EcoreFactory.eINSTANCE.createEPackage();
 		result.setName(name);
 		result.setNsURI(String.format("http://test/%s.ecore", name));
 		result.setNsPrefix(name);
 		return result;
 	}

 	Collection<EObject> everything() {
 		final Collection<EObject> result = new HashSet<EObject>();

 		final ResourceSet rset = testPackage.eResource().getResourceSet();
 		for (final Iterator<?> all = rset.getAllContents(); all.hasNext();) {
 			final Object next = all.next();
 			if (next instanceof EObject) {
 				result.add((EObject) next);
 			}
 		}

 		return result;
 	}

 	Runnable selectFirstElementInDialog(final boolean[] doIt) {
 		return new Runnable() {

 			@Override
 			public void run() {
 				if (doIt[0]) {
 					Shell shell = Display.getCurrent().getActiveShell();
 					if (shell == null) {
 						final Shell[] all = Display.getCurrent().getShells();
 						// Get the last opened
 						if (all.length > 0) {
 							shell = all[all.length - 1];
 						}
 					}
 					if (shell != null) {
 						selectFirstElement(shell);
 						finishWizard(shell);
 					}
 				}
 			}
 		};
 	}

 	static void selectFirstElement(Shell shell) {
 		Widget notify = null;
 		Item selected = null;

 		final Table table = findControl(shell, Table.class);
 		if (table != null) {
 			table.setSelection(0);
 			notify = table;
 			selected = table.getItem(0);
 		} else {
 			final Tree tree = findControl(shell, Tree.class);
 			if (tree != null) {
 				tree.setSelection(tree.getItem(0));
 				notify = tree;
 				selected = tree.getItem(0);
 			} else {
 				throw new IllegalStateException("no table nor tree to select");
 			}
 		}

 		// Have to fire notification for JFace viewer to pick up
 		final Event event = new Event();
 		event.type = SWT.Selection;
 		event.widget = notify;
 		event.item = selected;
 		notify.notifyListeners(SWT.Selection, event);
 	}

 	static <C extends Control> C findControl(Composite composite, Class<C> type) {
 		C result = null;

 		if (type.isInstance(composite)) {
 			result = type.cast(composite);
 		} else {
 			for (final Control child : composite.getChildren()) {
 				if (child instanceof Composite) {
 					result = findControl((Composite) child, type);
 				} else if (type.isInstance(child)) {
 					result = type.cast(child);
 				}

 				if (result != null) {
 					break;
 				}
 			}
 		}

 		return result;
 	}

 	static void finishWizard(Shell shell) {
 		final Dialog dialog = (Dialog) shell.getData();

 		try {
 			final Method buttonPressed = Dialog.class.getDeclaredMethod("buttonPressed", int.class);
 			buttonPressed.setAccessible(true);
 			buttonPressed.invoke(dialog, IDialogConstants.FINISH_ID);
 			// BEGIN COMPLEX CODE
 		} catch (final Exception e) {
 			// END COMPLEX CODE
 			throw new RuntimeException(e);
 		}
 	}

 	/**
 	 * Annotates a test method with the strategy provider class to inject as
 	 * a vendor in the {@linkplain BazaarRule bazaar fixture}.
 	 */
 	@Target(ElementType.METHOD)
 	@Retention(RetentionPolicy.RUNTIME)
 	@interface ProviderType {
 		Class<? extends Vendor<?>> value();
 	}

 	/**
 	 * A test rule that creates a bazaar with the single vendor specified by the
 	 * test's {@link ProviderType} annotation.
 	 */
 	static class BazaarRule implements TestRule {
 		private Bazaar<?> bazaar;

 		@Override
 		public Statement apply(final Statement base, final Description description) {
 			return new Statement() {

 				@Override
 				public void evaluate() throws Throwable {
 					starting(description);

 					try {
 						base.evaluate();
 					} finally {
 						finished(description);
 					}
 				}
 			};
 		}

 		protected void starting(Description description) throws InstantiationException, IllegalAccessException {
 			final Class<? extends Vendor<?>> strategyType = description
 				.getAnnotation(ProviderType.class).value();

 			final Vendor<?> provider = strategyType.newInstance();

 			final Bazaar.Builder<?> builder = Bazaar.Builder.with(singleton(provider));
 			bazaar = builder.build();
 		}

 		protected void finished(Description description) {
 			bazaar = null;
 		}

 		<S> S getStrategy(EObject owner, EReference reference) {
 			return getStrategy(owner, reference, null, null);
 		}

 		<S> S getStrategy(EObject owner, EReference reference, Object value) {
 			return getStrategy(owner, reference, value == null ? null : value.getClass().getName(), value);
 		}

 		@SuppressWarnings("unchecked")
 		<S> S getStrategy(EObject owner, EReference reference, String key,
 			Object value) {
 			final BazaarContext.Builder context = BazaarContext.Builder.empty();
 			context.put(EObject.class, owner).put(EReference.class, reference);
 			if (key != null) {
 				context.put(key, value);
 			}

 			return (S) bazaar.createProduct(context.build());
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2018 Christian W. Damus and others.
	*
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License 2.0
	* which accompanies this distribution, and is available at
	* https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	* Contributors:
	* Christian W. Damus - initial API and implementation
	******************************************************************************/
	package org.eclipse.emfforms.spi.editor;

	import static java.util.Collections.singleton;
	import static org.hamcrest.CoreMatchers.everyItem;
	import static org.hamcrest.CoreMatchers.hasItem;
	import static org.hamcrest.CoreMatchers.is;
	import static org.hamcrest.CoreMatchers.not;
	import static org.hamcrest.CoreMatchers.notNullValue;
	import static org.hamcrest.MatcherAssert.assertThat;

	import java.lang.annotation.ElementType;
	import java.lang.annotation.Retention;
	import java.lang.annotation.RetentionPolicy;
	import java.lang.annotation.Target;
	import java.lang.reflect.Method;
	import java.util.Arrays;
	import java.util.Collection;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.Set;

	import org.eclipse.emf.common.command.BasicCommandStack;
	import org.eclipse.emf.common.util.URI;
	import org.eclipse.emf.ecore.EAnnotation;
	import org.eclipse.emf.ecore.EAttribute;
	import org.eclipse.emf.ecore.EClass;
	import org.eclipse.emf.ecore.EClassifier;
	import org.eclipse.emf.ecore.EDataType;
	import org.eclipse.emf.ecore.ENamedElement;
	import org.eclipse.emf.ecore.EObject;
	import org.eclipse.emf.ecore.EPackage;
	import org.eclipse.emf.ecore.EReference;
	import org.eclipse.emf.ecore.EStructuralFeature;
	import org.eclipse.emf.ecore.EcoreFactory;
	import org.eclipse.emf.ecore.EcorePackage;
	import org.eclipse.emf.ecore.change.ChangeDescription;
	import org.eclipse.emf.ecore.change.ChangeFactory;
	import org.eclipse.emf.ecore.resource.Resource;
	import org.eclipse.emf.ecore.resource.ResourceSet;
	import org.eclipse.emf.ecp.ui.view.swt.reference.AttachmentStrategy;
	import org.eclipse.emf.ecp.ui.view.swt.reference.EObjectSelectionStrategy;
	import org.eclipse.emf.ecp.ui.view.swt.reference.OpenInNewContextStrategy;
	import org.eclipse.emf.ecp.ui.view.swt.reference.ReferenceStrategy;
	import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
	import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
	import org.eclipse.emfforms.bazaar.Bazaar;
	import org.eclipse.emfforms.bazaar.BazaarContext;
	import org.eclipse.emfforms.bazaar.Vendor;
	import org.eclipse.emfforms.internal.editor.ecore.referenceservices.EcoreAttachmentStrategyProvider;
	import org.eclipse.emfforms.internal.editor.ecore.referenceservices.EcoreEObjectSelectionStrategyProvider;
	import org.eclipse.emfforms.internal.editor.ecore.referenceservices.EcoreOpenInNewContextStrategyProvider;
	import org.eclipse.emfforms.internal.editor.ecore.referenceservices.EcoreReferenceStrategyProvider;
	import org.eclipse.jface.dialogs.Dialog;
	import org.eclipse.jface.dialogs.IDialogConstants;
	import org.eclipse.swt.SWT;
	import org.eclipse.swt.widgets.Composite;
	import org.eclipse.swt.widgets.Control;
	import org.eclipse.swt.widgets.Display;
	import org.eclipse.swt.widgets.Event;
	import org.eclipse.swt.widgets.Item;
	import org.eclipse.swt.widgets.Shell;
	import org.eclipse.swt.widgets.Table;
	import org.eclipse.swt.widgets.Tree;
	import org.eclipse.swt.widgets.Widget;
	import org.hamcrest.CoreMatchers;
	import org.junit.After;
	import org.junit.Assume;
	import org.junit.Before;
	import org.junit.Rule;
	import org.junit.Test;
	import org.junit.rules.TestRule;
	import org.junit.runner.Description;
	import org.junit.runners.model.Statement;
	import org.osgi.framework.InvalidSyntaxException;

	/**
	* Integration test cases for the Ecore Editor's reference service strategy provider classes.
	*/
	@SuppressWarnings({ "nls", "restriction" })
	public class EcoreReferenceServiceCustomizationProviders_ITest {

	@Rule
	public final BazaarRule bazaar = new BazaarRule();

	private EPackage testPackage;

	/**
	* Initializes me.
	*/
	public EcoreReferenceServiceCustomizationProviders_ITest() {
	super();
	}

	@ProviderType(EcoreReferenceStrategyProvider.class)
	@Test
	public void setEOppositeReference() throws InvalidSyntaxException {
	final EClass foo = (EClass) testPackage.getEClassifier("Foo");
	final EClass abstrakt = (EClass) testPackage.getEClassifier("Abstract");
	final EReference ref = (EReference) foo.getEStructuralFeature("ref");
	final EReference opposite = EcoreFactory.eINSTANCE.createEReference();
	abstrakt.getEStructuralFeatures().add(opposite);

	final ReferenceStrategy strategy = bazaar.getStrategy(foo, EcorePackage.Literals.EREFERENCE__EOPPOSITE);

	strategy.addElementsToReference(ref, EcorePackage.Literals.EREFERENCE__EOPPOSITE, singleton(opposite));

	assertThat("Reference's opposite not set", ref.getEOpposite(), is(opposite));
	assertThat("Opposite's opposite not set", opposite.getEOpposite(), is(ref));
	assertThat("Opposite's type not set", opposite.getEReferenceType(), is(foo));
	assertThat("Reference's type not set", ref.getEReferenceType(), is(abstrakt));
	}

	@ProviderType(EcoreAttachmentStrategyProvider.class)
	@Test
	public void attachOppositeReference() {
	final EClass foo = (EClass) testPackage.getEClassifier("Foo");
	final EClass abstrakt = (EClass) testPackage.getEClassifier("Abstract");
	final EReference ref = (EReference) foo.getEStructuralFeature("ref");
	ref.setEType(abstrakt);
	final EReference opposite = EcoreFactory.eINSTANCE.createEReference();

	final AttachmentStrategy strategy = bazaar.getStrategy(foo, EcorePackage.Literals.EREFERENCE__EOPPOSITE);

	strategy.addElementToModel(ref, EcorePackage.Literals.EREFERENCE__EOPPOSITE, opposite);

	assertThat("Opposite not added to its owner", opposite.getEContainingClass(), is(abstrakt));
	assertThat("Opposite's opposite not set", opposite.getEOpposite(), is(ref));
	assertThat("Opposite's type not set", opposite.getEReferenceType(), is(foo));
	assertThat("Opposite's name not set", opposite.getName(), notNullValue());
	}

	@ProviderType(EcoreEObjectSelectionStrategyProvider.class)
	@Test
	public void selectExistingEOpposite_refUntyped() {
	final EClass foo = (EClass) testPackage.getEClassifier("Foo");
	final EClass abstrakt = (EClass) testPackage.getEClassifier("Abstract");
	final EReference ref = (EReference) foo.getEStructuralFeature("ref");
	final EReference other = EcoreFactory.eINSTANCE.createEReference();
	other.setName("other");
	other.setEType(foo);
	foo.getEStructuralFeatures().add(other);
	final EReference opposite = EcoreFactory.eINSTANCE.createEReference();
	abstrakt.getEStructuralFeatures().add(opposite);

	final EObjectSelectionStrategy strategy = bazaar.getStrategy(foo, EcorePackage.Literals.EREFERENCE__EOPPOSITE);

	Collection<EObject> selection = everything();
	selection = strategy.collectExistingObjects(ref, EcorePackage.Literals.EREFERENCE__EOPPOSITE, selection);

	assertThat(selection, everyItem(CoreMatchers.<EObject> instanceOf(EReference.class)));
	assertThat(selection, hasItem(opposite));
	assertThat(selection, not(hasItem(ref)));
	assertThat(selection, hasItem(other)); // Could be an opposite, in theory
	}

	@ProviderType(EcoreEObjectSelectionStrategyProvider.class)
	@Test
	public void selectExistingEOpposite_refHasType() {
	final EClass foo = (EClass) testPackage.getEClassifier("Foo");
	final EClass abstrakt = (EClass) testPackage.getEClassifier("Abstract");
	final EReference ref = (EReference) foo.getEStructuralFeature("ref");
	final EReference other = EcoreFactory.eINSTANCE.createEReference();
	other.setName("other");
	other.setEType(foo);
	foo.getEStructuralFeatures().add(other);
	ref.setEType(abstrakt); // This determines the type that may contain opposites
	final EReference opposite = EcoreFactory.eINSTANCE.createEReference();
	abstrakt.getEStructuralFeatures().add(opposite);

	final EObjectSelectionStrategy strategy = bazaar.getStrategy(foo, EcorePackage.Literals.EREFERENCE__EOPPOSITE);

	Collection<EObject> selection = everything();
	selection = strategy.collectExistingObjects(ref, EcorePackage.Literals.EREFERENCE__EOPPOSITE, selection);

	assertThat(selection, everyItem(CoreMatchers.<EObject> instanceOf(EReference.class)));
	assertThat(selection, hasItem(opposite));
	assertThat(selection, not(hasItem(ref)));
	assertThat(selection, not(hasItem(other))); // Not in the ref's type
	}

	@ProviderType(EcoreEObjectSelectionStrategyProvider.class)
	@Test
	public void selectExistingSupertype() {
	final EClass foo = (EClass) testPackage.getEClassifier("Foo");
	final EClass abstrakt = (EClass) testPackage.getEClassifier("Abstract");
	final EClass subclass = EcoreFactory.eINSTANCE.createEClass();
	subclass.setName("Subtype");
	subclass.getESuperTypes().add(foo);
	testPackage.getEClassifiers().add(subclass);

	final EObjectSelectionStrategy strategy = bazaar.getStrategy(foo, EcorePackage.Literals.ECLASS__ESUPER_TYPES);

	Collection<EObject> selection = everything();
	selection = strategy.collectExistingObjects(foo, EcorePackage.Literals.ECLASS__ESUPER_TYPES, selection);

	assertThat(selection, everyItem(CoreMatchers.<EObject> instanceOf(EClass.class)));
	assertThat(selection, hasItem(abstrakt));
	assertThat(selection, not(hasItem(subclass))); // Would cause cycle
	}

	@ProviderType(EcoreEObjectSelectionStrategyProvider.class)
	@Test
	public void selectExistingAttributeType() {
	final EClass foo = (EClass) testPackage.getEClassifier("Foo");
	final EClassifier intType = testPackage.getEClassifier("int");
	final EStructuralFeature attr = foo.getEStructuralFeature("attr");

	final EObjectSelectionStrategy strategy = bazaar.getStrategy(attr, EcorePackage.Literals.ETYPED_ELEMENT__ETYPE);

	Collection<EObject> selection = everything();
	selection = strategy.collectExistingObjects(attr, EcorePackage.Literals.ETYPED_ELEMENT__ETYPE, selection);

	assertThat(selection, everyItem(CoreMatchers.<EObject> instanceOf(EDataType.class)));
	assertThat(selection, hasItem(intType));
	}

	@ProviderType(EcoreEObjectSelectionStrategyProvider.class)
	@Test
	public void selectExistingAnnotationReference() {
	final EClass foo = (EClass) testPackage.getEClassifier("Foo");
	final EClassifier intType = testPackage.getEClassifier("int");
	final EAnnotation annotation = EcoreFactory.eINSTANCE.createEAnnotation();
	annotation.setSource("test");
	foo.getEAnnotations().add(annotation);
	final EObjectSelectionStrategy strategy = bazaar.getStrategy(annotation,
	EcorePackage.Literals.EANNOTATION__REFERENCES);

	final ChangeDescription change = ChangeFactory.eINSTANCE.createChangeDescription();
	foo.eResource().getContents().add(change);

	Collection<EObject> selection = everything();
	Assume.assumeThat(selection, hasItem(change));
	selection = strategy.collectExistingObjects(annotation, EcorePackage.Literals.EANNOTATION__REFERENCES,
	selection);

	assertThat(selection, everyItem(CoreMatchers.<EObject> instanceOf(ENamedElement.class)));
	assertThat(selection, hasItem(intType));
	assertThat(selection, not(hasItem(change)));
	}

	@ProviderType(EcoreOpenInNewContextStrategyProvider.class)
	@Test
	public void openInNewContext() {
	final EClassifier foo = testPackage.getEClassifier("Foo");
	final OpenInNewContextStrategy strategy = bazaar.getStrategy(foo, foo.eContainmentFeature());
	assertThat(strategy, notNullValue());

	final Set<Shell> expectedShells = new HashSet<Shell>(Arrays.asList(Display.getCurrent().getShells()));

	// If a dialog appears close it
	final boolean[] doIt = { true };
	final boolean[] sawDialog = { false };
	Display.getDefault().asyncExec(new Runnable() {

	@Override
	public void run() {
	if (!doIt[0]) {
	return;
	}

	for (final Shell next : Display.getCurrent().getShells()) {
	if (!expectedShells.contains(next)) {
	sawDialog[0] = true;
	next.close();
	}
	}
	}
	});

	strategy.openInNewContext(foo.eContainer(), foo.eContainmentFeature(), foo);

	// If the dialog didn't appear, don't try anything after the test suite has moved on
	doIt[0] = false;

	assertThat("Open strategy presented a dialog", sawDialog[0], is(false));
	}

	//
	// Test framework
	//

	@Before
	public void createFixture() {
	final AdapterFactoryEditingDomain domain = new AdapterFactoryEditingDomain(
	new ComposedAdapterFactory(ComposedAdapterFactory.Descriptor.Registry.INSTANCE),
	new BasicCommandStack());

	testPackage = createTestPackage();
	createResource(domain.getResourceSet(), testPackage);
	}

	@After
	public void destroyFixture() {
	testPackage = null;
	}

	EPackage createTestPackage() {
	final EPackage result = createPackage("test");
	final EClass foo = EcoreFactory.eINSTANCE.createEClass();
	foo.setName("Foo");
	result.getEClassifiers().add(foo);
	final EAttribute state = EcoreFactory.eINSTANCE.createEAttribute();
	state.setName("attr");
	foo.getEStructuralFeatures().add(state);
	final EReference ref = EcoreFactory.eINSTANCE.createEReference();
	ref.setName("ref");
	foo.getEStructuralFeatures().add(ref);
	final EClass abstrakt = EcoreFactory.eINSTANCE.createEClass();
	abstrakt.setAbstract(true);
	abstrakt.setName("Abstract");
	result.getEClassifiers().add(abstrakt);
	final EDataType intType = EcoreFactory.eINSTANCE.createEDataType();
	intType.setName("int");
	intType.setInstanceTypeName("int");
	result.getEClassifiers().add(intType);
	return result;
	}

	void createResource(ResourceSet rset, EPackage ePackage) {
	final Resource resource = rset.createResource(URI.createURI(ePackage.getNsURI()).appendFileExtension("ecore"));
	resource.getContents().add(ePackage);
	}

	EPackage createPackage(String name) {
	final EPackage result = EcoreFactory.eINSTANCE.createEPackage();
	result.setName(name);
	result.setNsURI(String.format("http://test/%s.ecore", name));
	result.setNsPrefix(name);
	return result;
	}

	Collection<EObject> everything() {
	final Collection<EObject> result = new HashSet<EObject>();

	final ResourceSet rset = testPackage.eResource().getResourceSet();
	for (final Iterator<?> all = rset.getAllContents(); all.hasNext();) {
	final Object next = all.next();
	if (next instanceof EObject) {
	result.add((EObject) next);
	}
	}

	return result;
	}

	Runnable selectFirstElementInDialog(final boolean[] doIt) {
	return new Runnable() {

	@Override
	public void run() {
	if (doIt[0]) {
	Shell shell = Display.getCurrent().getActiveShell();
	if (shell == null) {
	final Shell[] all = Display.getCurrent().getShells();
	// Get the last opened
	if (all.length > 0) {
	shell = all[all.length - 1];
	}
	}
	if (shell != null) {
	selectFirstElement(shell);
	finishWizard(shell);
	}
	}
	}
	};
	}

	static void selectFirstElement(Shell shell) {
	Widget notify = null;
	Item selected = null;

	final Table table = findControl(shell, Table.class);
	if (table != null) {
	table.setSelection(0);
	notify = table;
	selected = table.getItem(0);
	} else {
	final Tree tree = findControl(shell, Tree.class);
	if (tree != null) {
	tree.setSelection(tree.getItem(0));
	notify = tree;
	selected = tree.getItem(0);
	} else {
	throw new IllegalStateException("no table nor tree to select");
	}
	}

	// Have to fire notification for JFace viewer to pick up
	final Event event = new Event();
	event.type = SWT.Selection;
	event.widget = notify;
	event.item = selected;
	notify.notifyListeners(SWT.Selection, event);
	}

	static <C extends Control> C findControl(Composite composite, Class<C> type) {
	C result = null;

	if (type.isInstance(composite)) {
	result = type.cast(composite);
	} else {
	for (final Control child : composite.getChildren()) {
	if (child instanceof Composite) {
	result = findControl((Composite) child, type);
	} else if (type.isInstance(child)) {
	result = type.cast(child);
	}

	if (result != null) {
	break;
	}
	}
	}

	return result;
	}

	static void finishWizard(Shell shell) {
	final Dialog dialog = (Dialog) shell.getData();

	try {
	final Method buttonPressed = Dialog.class.getDeclaredMethod("buttonPressed", int.class);
	buttonPressed.setAccessible(true);
	buttonPressed.invoke(dialog, IDialogConstants.FINISH_ID);
	// BEGIN COMPLEX CODE
	} catch (final Exception e) {
	// END COMPLEX CODE
	throw new RuntimeException(e);
	}
	}

	/**
	* Annotates a test method with the strategy provider class to inject as
	* a vendor in the {@linkplain BazaarRule bazaar fixture}.
	*/
	@Target(ElementType.METHOD)
	@Retention(RetentionPolicy.RUNTIME)
	@interface ProviderType {
	Class<? extends Vendor<?>> value();
	}

	/**
	* A test rule that creates a bazaar with the single vendor specified by the
	* test's {@link ProviderType} annotation.
	*/
	static class BazaarRule implements TestRule {
	private Bazaar<?> bazaar;

	@Override
	public Statement apply(final Statement base, final Description description) {
	return new Statement() {

	@Override
	public void evaluate() throws Throwable {
	starting(description);

	try {
	base.evaluate();
	} finally {
	finished(description);
	}
	}
	};
	}

	protected void starting(Description description) throws InstantiationException, IllegalAccessException {
	final Class<? extends Vendor<?>> strategyType = description
	.getAnnotation(ProviderType.class).value();

	final Vendor<?> provider = strategyType.newInstance();

	final Bazaar.Builder<?> builder = Bazaar.Builder.with(singleton(provider));
	bazaar = builder.build();
	}

	protected void finished(Description description) {
	bazaar = null;
	}

	<S> S getStrategy(EObject owner, EReference reference) {
	return getStrategy(owner, reference, null, null);
	}

	<S> S getStrategy(EObject owner, EReference reference, Object value) {
	return getStrategy(owner, reference, value == null ? null : value.getClass().getName(), value);
	}

	@SuppressWarnings("unchecked")
	<S> S getStrategy(EObject owner, EReference reference, String key,
	Object value) {
	final BazaarContext.Builder context = BazaarContext.Builder.empty();
	context.put(EObject.class, owner).put(EReference.class, reference);
	if (key != null) {
	context.put(key, value);
	}

	return (S) bazaar.createProduct(context.build());
	}
	}
	}