Attachment #226902 for bug #400534

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

View | Details | Raw Unified | Return to bug 400534
Collapse All | Expand All

Added Link Here

(-)a/ECP2/org.eclipse.emf.ecp.core.test/.classpath (+7 lines)
1	<?xml version="1.0" encoding="UTF-8"?>
2	<classpath>
3	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
4	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
5	<classpathentry kind="src" path="src"/>
6	<classpathentry kind="output" path="bin"/>
7	</classpath>




<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
	<name>org.eclipse.emf.ecp.core.test</name>
	<comment></comment>
	<projects>
	</projects>
	<buildSpec>
		<buildCommand>
			<name>org.eclipse.jdt.core.javabuilder</name>
			<arguments>
			</arguments>
		</buildCommand>
		<buildCommand>
			<name>org.eclipse.pde.ManifestBuilder</name>
			<arguments>
			</arguments>
		</buildCommand>
		<buildCommand>
			<name>org.eclipse.pde.SchemaBuilder</name>
			<arguments>
			</arguments>
		</buildCommand>
	</buildSpec>
	<natures>
		<nature>org.eclipse.pde.PluginNature</nature>
		<nature>org.eclipse.jdt.core.javanature</nature>
	</natures>
</projectDescription>

Added Link Here

(-)a/ECP2/org.eclipse.emf.ecp.core.test/.settings/org.eclipse.jdt.core.prefs (+7 lines)
1	eclipse.preferences.version=1
2	org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
3	org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
4	org.eclipse.jdt.core.compiler.compliance=1.5
5	org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
6	org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
7	org.eclipse.jdt.core.compiler.source=1.5




Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: Test
Bundle-SymbolicName: org.eclipse.emf.ecp.core.test
Bundle-Version: 1.0.0.qualifier
Bundle-Activator: org.eclipse.emf.ecp.core.test.Activator
Require-Bundle: org.eclipse.ui,
 org.eclipse.core.runtime,
 org.eclipse.emf.ecp.core;bundle-version="1.0.0",
 org.junit4;bundle-version="4.8.1",
 org.eclipse.emf.ecp.emfstore.core;bundle-version="1.0.0",
 org.eclipse.emf.ecp.example.bowlingmodel;bundle-version="1.0.0",
 org.eclipse.net4j.util;bundle-version="3.2.1"
Bundle-ActivationPolicy: lazy
Bundle-RequiredExecutionEnvironment: J2SE-1.5

Added Link Here

(-)a/ECP2/org.eclipse.emf.ecp.core.test/build.properties (+4 lines)
1	source.. = src/
2	output.. = bin/
3	bin.includes = META-INF/,\
4	.




package org.eclipse.emf.ecp.core.test;

import org.eclipse.emf.ecp.core.ECPProjectManager;
import org.eclipse.emf.ecp.core.ECPProvider;
import org.eclipse.emf.ecp.core.ECPProviderRegistry;
import org.eclipse.emf.ecp.core.ECPRepository;
import org.eclipse.emf.ecp.core.ECPRepositoryManager;
import org.eclipse.emf.ecp.core.exception.ProjectWithNameExistsException;
import org.eclipse.emf.ecp.core.util.ECPProperties;
import org.eclipse.emf.ecp.core.util.ECPUtil;
import org.eclipse.emf.ecp.emfstore.core.internal.EMFStoreProvider;
import org.junit.BeforeClass;

/**
 * Abstract Test Class using EMFStoreProvider as ECPProvider
 * 
 * @author jfaltermeier
 * 
 */
public abstract class AbstractTest {
	private static ECPProjectManager projectManager;
	private static ECPProvider provider;
	private ECPProviderRegistry providerRegistry;
	private static ECPRepository repository;
	private ECPRepositoryManager repositoryManager;

	@BeforeClass
	public static void init() throws ProjectWithNameExistsException {
		provider = ECPProviderRegistry.INSTANCE.getProvider(EMFStoreProvider.NAME);
		repository = ECPRepositoryManager.INSTANCE.addRepository(provider, "repositoryName", "repositoryLabel",
			"description", getNewProperties());
		projectManager = ECPProjectManager.INSTANCE;
	}

	public static ECPProjectManager getProjectManager() {
		return projectManager;
	}

	public static ECPProvider getProvider() {
		return provider;
	}

	public ECPRepository getRepository() {
		return repository;
	}

	public static ECPProperties getNewProperties() {
		ECPProperties properties = ECPUtil.createProperties();
		properties.addProperty(EMFStoreProvider.PROP_REPOSITORY_URL, "localhost");
		properties.addProperty(EMFStoreProvider.PROP_PORT, "8080");
		properties.addProperty(EMFStoreProvider.PROP_CERTIFICATE, "foo");
		return properties;
	}
}




package org.eclipse.emf.ecp.core.test;

import org.eclipse.ui.plugin.AbstractUIPlugin;
import org.osgi.framework.BundleContext;

/**
 * The activator class controls the plug-in life cycle
 */
public class Activator extends AbstractUIPlugin {

	// The plug-in ID
	public static final String PLUGIN_ID = "org.eclipse.emf.ecp.core.test"; //$NON-NLS-1$

	// The shared instance
	private static Activator plugin;
	
	/**
	 * The constructor
	 */
	public Activator() {
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext)
	 */
	public void start(BundleContext context) throws Exception {
		super.start(context);
		plugin = this;
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext)
	 */
	public void stop(BundleContext context) throws Exception {
		plugin = null;
		super.stop(context);
	}

	/**
	 * Returns the shared instance
	 *
	 * @return the shared instance
	 */
	public static Activator getDefault() {
		return plugin;
	}

}




package org.eclipse.emf.ecp.core.test;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import org.eclipse.emf.ecp.core.ECPProject;
import org.eclipse.emf.ecp.core.exception.ProjectWithNameExistsException;
import org.eclipse.emf.ecp.core.util.ECPProperties;
import org.eclipse.emf.ecp.core.util.observer.IECPProjectsChangedUIObserver;
import org.eclipse.emf.ecp.internal.core.ECPProjectManagerImpl;
import org.eclipse.emf.edit.command.SetCommand;
import org.junit.After;
import org.junit.Test;

import bowling.BowlingFactory;
import bowling.BowlingPackage;
import bowling.Player;

/**
 * ECPProjectManager Tests
 * 
 * @author jfaltermeier
 * 
 */
public class ECPProjectManagerTests extends AbstractTest {

	private String projectName = "name";
	private ECPProject project;
	private ECPProject project2;
	private ECPProject project3;

	@After
	public void tearDown() {
		if (project != null) {
			ECPProjectManagerImpl.INSTANCE.changeElements(Collections.singleton(project.getName()), null);
			project.delete();
		}
		if (project2 != null) {
			ECPProjectManagerImpl.INSTANCE.changeElements(Collections.singleton(project2.getName()), null);
			project2.delete();
		}
		if (project3 != null) {
			ECPProjectManagerImpl.INSTANCE.changeElements(Collections.singleton(project3.getName()), null);
			project3.delete();
		}
	}

	@Test
	public void createOfflineProjectTest() {
		try {
			assertTrue(!Arrays.asList(getProjectManager().getProjects()).contains(project));
			project = getProjectManager().createProject(getProvider(), projectName);
			assertTrue(Arrays.asList(getProjectManager().getProjects()).contains(project));
			assertTrue(project != null);
			assertEquals(getProvider(), project.getProvider());
			assertEquals(projectName, project.getName());
		} catch (ProjectWithNameExistsException e) {
			fail("Project with name already existing. Fix test setup.");
		}
	}

	@Test(expected = ProjectWithNameExistsException.class)
	public void createOfflineProjectWithExistingNameTest() throws ProjectWithNameExistsException {

		try {
			assertTrue(!Arrays.asList(getProjectManager().getProjects()).contains(project));
			project = getProjectManager().createProject(getProvider(), projectName);
			assertTrue(Arrays.asList(getProjectManager().getProjects()).contains(project));
			assertTrue(project != null);
			assertEquals(getProvider(), project.getProvider());
			assertEquals(projectName, project.getName());
		} catch (ProjectWithNameExistsException e) {
			fail("Project with name already existing. Fix test setup.");
		}

		assertTrue(!Arrays.asList(getProjectManager().getProjects()).contains(project2));
		project2 = getProjectManager().createProject(getProvider(), projectName);
	}

	@Test
	public void createOfflineProjectWithPropertiesTest() {
		ECPProperties properties = getNewProperties();
		try {
			assertTrue(!Arrays.asList(getProjectManager().getProjects()).contains(project));
			project = getProjectManager().createProject(getProvider(), projectName, properties);
			assertTrue(Arrays.asList(getProjectManager().getProjects()).contains(project));
			assertTrue(project != null);
			assertEquals(projectName, project.getName());
			assertEquals(getProvider(), project.getProvider());
			assertEquals(properties, project.getProperties());
		} catch (ProjectWithNameExistsException e) {
			fail("Project with name already existing. Fix test setup.");
		}
	}

	@Test(expected = ProjectWithNameExistsException.class)
	public void createOfflineProjectWithPropertiesAndExistingNameTest() throws ProjectWithNameExistsException {
		ECPProperties properties = getNewProperties();

		try {
			assertTrue(!Arrays.asList(getProjectManager().getProjects()).contains(project));
			project = getProjectManager().createProject(getProvider(), projectName, properties);
			assertTrue(Arrays.asList(getProjectManager().getProjects()).contains(project));
			assertTrue(project != null);
			assertEquals(projectName, project.getName());
			assertEquals(getProvider(), project.getProvider());
			assertEquals(properties, project.getProperties());
		} catch (ProjectWithNameExistsException e) {
			fail("Project with name already existing. Fix test setup.");
		}

		assertTrue(!Arrays.asList(getProjectManager().getProjects()).contains(project2));
		project2 = getProjectManager().createProject(getProvider(), projectName, getNewProperties());
	}

	@Test
	public void createSharedProject() {
		ECPProperties properties = getNewProperties();
		try {
			assertTrue(!Arrays.asList(getProjectManager().getProjects()).contains(project));
			project = getProjectManager().createProject(getRepository(), projectName, properties);
			assertTrue(Arrays.asList(getProjectManager().getProjects()).contains(project));
			assertTrue(project != null);
			assertEquals(projectName, project.getName());
			assertEquals(getRepository(), project.getRepository());
			assertEquals(properties, project.getProperties());
		} catch (ProjectWithNameExistsException e) {
			fail("Project with name already existing. Fix test setup.");
		}
	}

	@Test(expected = ProjectWithNameExistsException.class)
	public void createSharedWithExistingNameProject() throws ProjectWithNameExistsException {
		ECPProperties properties = getNewProperties();
		try {
			assertTrue(!Arrays.asList(getProjectManager().getProjects()).contains(project));
			project = getProjectManager().createProject(getRepository(), projectName, properties);
			assertTrue(Arrays.asList(getProjectManager().getProjects()).contains(project));
			assertTrue(project != null);
			assertEquals(projectName, project.getName());
			assertEquals(getRepository(), project.getRepository());
			assertEquals(properties, project.getProperties());
		} catch (ProjectWithNameExistsException e) {
			fail("Project with name already existing. Fix test setup.");
		}

		assertTrue(!Arrays.asList(getProjectManager().getProjects()).contains(project2));
		project2 = getProjectManager().createProject(getRepository(), projectName, properties);

	}

	@Test
	public void cloneProjectTest() {
		try {
			project = getProjectManager().createProject(getProvider(), projectName);
		} catch (ProjectWithNameExistsException e) {
			fail("Project with name already existing. Fix test setup.");
		}
		project2 = getProjectManager().cloneProject(project);
		assertEquals(project.getName() + "(Copy)", project2.getName());
		assertEquals(project.getElements(), project2.getElements());
		assertEquals(project.getUnsupportedEPackages(), project2.getUnsupportedEPackages());
		assertEquals(project.getVisibleEClasses(), project2.getVisibleEClasses());
		assertEquals(project.getVisiblePackages(), project2.getVisiblePackages());
	}

	@Test
	public void getProjectWithAdaptableTest() {
		try {
			project = getProjectManager().createProject(getProvider(), projectName);

			Player player = BowlingFactory.eINSTANCE.createPlayer();
			project.getElements().add(player);

			assertTrue(project.getElements().contains(player));
			assertSame(project, getProjectManager().getProject(player));
		} catch (ProjectWithNameExistsException e) {
			fail("Project with name already existing. Fix test setup.");
		}
	}

	@Test
	public void getProjectWithNameTest() {
		try {
			project = getProjectManager().createProject(getProvider(), projectName);
			assertSame(project, getProjectManager().getProject(projectName));
		} catch (ProjectWithNameExistsException e) {
			fail("Project with name already existing. Fix test setup.");
		}
	}

	@Test
	public void getProjectWithNameNonExistingTest() {
		project = getProjectManager().getProject("newNameThatNobodyUses");
		assertEquals(null, project);
	}

	@Test
	public void getProjectsTest() {
		try {
			List<ECPProject> projects = Arrays.asList(getProjectManager().getProjects());
			assertTrue(projects.size() == 0);
			assertTrue(!projects.contains(project));
			assertTrue(!projects.contains(project2));
			assertTrue(!projects.contains(project3));

			project = getProjectManager().createProject(getProvider(), "p1");
			project2 = getProjectManager().createProject(getProvider(), "p2");
			project3 = getProjectManager().createProject(getProvider(), "p3");
			projects = Arrays.asList(getProjectManager().getProjects());

			assertTrue(projects.size() == 3);
			assertTrue(projects.contains(project));
			assertTrue(projects.contains(project2));
			assertTrue(projects.contains(project3));
		} catch (ProjectWithNameExistsException e) {
			fail("Project with name already existing. Fix test setup.");
		}
	}

	@Test
	public void addAndRemoveObserverTest() {
		try {
			project = getProjectManager().createProject(getProvider(), projectName);
			Player player = BowlingFactory.eINSTANCE.createPlayer();
			project.getElements().add(player);
			TestIECPProjectsChangedUIObserver obs = new TestIECPProjectsChangedUIObserver();

			// add observer
			getProjectManager().addObserver(obs);

			// make sure objectsChangedReached is false
			obs.getAndResetObjectsChangedReached();

			// change name -> invoke projectChanged to be called
			project
				.getEditingDomain()
				.getCommandStack()
				.execute(
					SetCommand.create(project.getEditingDomain(), player, BowlingPackage.eINSTANCE.getPlayer_Name(),
						"Sepp"));
			assertTrue(obs.getAndResetObjectsChangedReached());

			// change name again after removing observer -> obs should not be called
			getProjectManager().removeObserver(obs);
			project
				.getEditingDomain()
				.getCommandStack()
				.execute(
					SetCommand.create(project.getEditingDomain(), player, BowlingPackage.eINSTANCE.getPlayer_Name(),
						"Seppi"));
			assertFalse(obs.getAndResetObjectsChangedReached());
		} catch (ProjectWithNameExistsException e) {
			fail("Project with name already existing. Fix test setup.");
		}
	}

	/**
	 * Observer implementation for testing purposes
	 * 
	 * @author jfaltermeier
	 * 
	 */
	private class TestIECPProjectsChangedUIObserver implements IECPProjectsChangedUIObserver {
		private boolean objectsChangedReached = false;

		public void projectsChanged(ECPProject[] oldProjects, ECPProject[] newProjects) throws Exception {
		}

		public void projectChanged(ECPProject project, boolean opened) throws Exception {
		}

		public void objectsChanged(ECPProject project, Object[] objects, boolean structural) throws Exception {
			objectsChangedReached = true;
		}

		public boolean getAndResetObjectsChangedReached() {
			boolean toReturn = objectsChangedReached;
			objectsChangedReached = false;
			return toReturn;
		}
	};
}




package org.eclipse.emf.ecp.core.test;

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

import java.util.Arrays;
import java.util.List;

import org.eclipse.emf.ecp.core.ECPProject;
import org.eclipse.emf.ecp.core.ECPRepository;
import org.eclipse.emf.ecp.core.ECPRepositoryManager;
import org.eclipse.emf.ecp.core.exception.ProjectWithNameExistsException;
import org.junit.After;
import org.junit.Test;

/**
 * ECPProvider Tests
 * 
 * @author jfaltermeier
 * 
 */
public class ECPProviderTests extends AbstractTest {

	private ECPRepository repository;

	@After
	public void tearDown() {
		if (repository != null) {
			repository.delete();
		}
	}

	@Test
	public void getLabelTest() {
		// TODO any programmatic way to get label-string of EMFStore provider?
		assertEquals("EMFStore", getProvider().getLabel());
	}

	@Test
	public void getRepositoriesTest() {
		List<ECPRepository> repositories = Arrays.asList(getProvider().getRepositories());
		assertTrue(repositories.contains(getRepository()));
	}

	@Test
	public void canAddRepositoriesTest() {
		boolean canAddRepositories = getProvider().canAddRepositories();

		int countReposBefore = getProvider().getRepositories().length;
		repository = ECPRepositoryManager.INSTANCE.addRepository(getProvider(), "repository4Name", "repository4Label",
			"description", getNewProperties());
		int countReposAfterAdd = getProvider().getRepositories().length;

		if (countReposAfterAdd - countReposBefore == 1) {
			assertTrue(canAddRepositories);
		} else if (countReposAfterAdd - countReposBefore == 0) {
			assertFalse(canAddRepositories);
		} else {
			fail("More than one repository was added or deleted.");
		}

	}

	@Test
	public void hasUnsharedProjectSupportTest() {
		boolean hasUnsharedProjectSupport = getProvider().hasUnsharedProjectSupport();
		boolean isActuallyPossible = false;

		try {
			// try to create an offline project;
			ECPProject project = getProjectManager().createProject(getProvider(), "test");
			if (project == null && !Arrays.asList(getProjectManager().getProjects()).contains(project)) {
				isActuallyPossible = false;
			} else {
				isActuallyPossible = true;
			}
		} catch (ProjectWithNameExistsException e) {
			fail("Project with name already existing. Fix test setup.");
		} catch (Exception e) {
			isActuallyPossible = false;
		}

		assertEquals(hasUnsharedProjectSupport, isActuallyPossible);
	}
}

Return to bug 400534

Added Link Here

(-)a/ECP2/org.eclipse.emf.ecp.core.test/src/org/eclipse/emf/ecp/core/test/ECPProviderTests.java (+87 lines)
1	package org.eclipse.emf.ecp.core.test;
2
3	import static org.junit.Assert.assertEquals;
4	import static org.junit.Assert.assertFalse;
5	import static org.junit.Assert.assertTrue;
6	import static org.junit.Assert.fail;
7
8	import java.util.Arrays;
9	import java.util.List;
10
11	import org.eclipse.emf.ecp.core.ECPProject;
12	import org.eclipse.emf.ecp.core.ECPRepository;
13	import org.eclipse.emf.ecp.core.ECPRepositoryManager;
14	import org.eclipse.emf.ecp.core.exception.ProjectWithNameExistsException;
15	import org.junit.After;
16	import org.junit.Test;
17
18	/**
19	* ECPProvider Tests
20	*
21	* @author jfaltermeier
22	*
23	*/
24	public class ECPProviderTests extends AbstractTest {
25
26	private ECPRepository repository;
27
28	@After
29	public void tearDown() {
30	if (repository != null) {
31	repository.delete();
32	}
33	}
34
35	@Test
36	public void getLabelTest() {
37	// TODO any programmatic way to get label-string of EMFStore provider?
38	assertEquals("EMFStore", getProvider().getLabel());
39	}
40
41	@Test
42	public void getRepositoriesTest() {
43	List<ECPRepository> repositories = Arrays.asList(getProvider().getRepositories());
44	assertTrue(repositories.contains(getRepository()));
45	}
46
47	@Test
48	public void canAddRepositoriesTest() {
49	boolean canAddRepositories = getProvider().canAddRepositories();
50
51	int countReposBefore = getProvider().getRepositories().length;
52	repository = ECPRepositoryManager.INSTANCE.addRepository(getProvider(), "repository4Name", "repository4Label",
53	"description", getNewProperties());
54	int countReposAfterAdd = getProvider().getRepositories().length;
55
56	if (countReposAfterAdd - countReposBefore == 1) {
57	assertTrue(canAddRepositories);
58	} else if (countReposAfterAdd - countReposBefore == 0) {
59	assertFalse(canAddRepositories);
60	} else {
61	fail("More than one repository was added or deleted.");
62	}
63
64	}
65
66	@Test
67	public void hasUnsharedProjectSupportTest() {
68	boolean hasUnsharedProjectSupport = getProvider().hasUnsharedProjectSupport();
69	boolean isActuallyPossible = false;
70
71	try {
72	// try to create an offline project;
73	ECPProject project = getProjectManager().createProject(getProvider(), "test");
74	if (project == null && !Arrays.asList(getProjectManager().getProjects()).contains(project)) {
75	isActuallyPossible = false;
76	} else {
77	isActuallyPossible = true;
78	}
79	} catch (ProjectWithNameExistsException e) {
80	fail("Project with name already existing. Fix test setup.");
81	} catch (Exception e) {
82	isActuallyPossible = false;
83	}
84
85	assertEquals(hasUnsharedProjectSupport, isActuallyPossible);
86	}
87	}

Added Link Here

(-)a/ECP2/org.eclipse.emf.ecp.core.test/.project (+28 lines)
1	<?xml version="1.0" encoding="UTF-8"?>
2	<projectDescription>
3	<name>org.eclipse.emf.ecp.core.test</name>
4	<comment></comment>
5	<projects>
6	</projects>
7	<buildSpec>
8	<buildCommand>
9	<name>org.eclipse.jdt.core.javabuilder</name>
10	<arguments>
11	</arguments>
12	</buildCommand>
13	<buildCommand>
14	<name>org.eclipse.pde.ManifestBuilder</name>
15	<arguments>
16	</arguments>
17	</buildCommand>
18	<buildCommand>
19	<name>org.eclipse.pde.SchemaBuilder</name>
20	<arguments>
21	</arguments>
22	</buildCommand>
23	</buildSpec>
24	<natures>
25	<nature>org.eclipse.pde.PluginNature</nature>
26	<nature>org.eclipse.jdt.core.javanature</nature>
27	</natures>
28	</projectDescription>

Added Link Here

(-)a/ECP2/org.eclipse.emf.ecp.core.test/META-INF/MANIFEST.MF (+15 lines)
1	Manifest-Version: 1.0
2	Bundle-ManifestVersion: 2
3	Bundle-Name: Test
4	Bundle-SymbolicName: org.eclipse.emf.ecp.core.test
5	Bundle-Version: 1.0.0.qualifier
6	Bundle-Activator: org.eclipse.emf.ecp.core.test.Activator
7	Require-Bundle: org.eclipse.ui,
8	org.eclipse.core.runtime,
9	org.eclipse.emf.ecp.core;bundle-version="1.0.0",
10	org.junit4;bundle-version="4.8.1",
11	org.eclipse.emf.ecp.emfstore.core;bundle-version="1.0.0",
12	org.eclipse.emf.ecp.example.bowlingmodel;bundle-version="1.0.0",
13	org.eclipse.net4j.util;bundle-version="3.2.1"
14	Bundle-ActivationPolicy: lazy
15	Bundle-RequiredExecutionEnvironment: J2SE-1.5

Added Link Here

(-)a/ECP2/org.eclipse.emf.ecp.core.test/src/org/eclipse/emf/ecp/core/test/Activator.java (+50 lines)
1	package org.eclipse.emf.ecp.core.test;
2
3	import org.eclipse.ui.plugin.AbstractUIPlugin;
4	import org.osgi.framework.BundleContext;
5
6	/**
7	* The activator class controls the plug-in life cycle
8	*/
9	public class Activator extends AbstractUIPlugin {
10
11	// The plug-in ID
12	public static final String PLUGIN_ID = "org.eclipse.emf.ecp.core.test"; //$NON-NLS-1$
13
14	// The shared instance
15	private static Activator plugin;
16
17	/**
18	* The constructor
19	*/
20	public Activator() {
21	}
22
23	/*
24	* (non-Javadoc)
25	* @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext)
26	*/
27	public void start(BundleContext context) throws Exception {
28	super.start(context);
29	plugin = this;
30	}
31
32	/*
33	* (non-Javadoc)
34	* @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext)
35	*/
36	public void stop(BundleContext context) throws Exception {
37	plugin = null;
38	super.stop(context);
39	}
40
41	/**
42	* Returns the shared instance
43	*
44	* @return the shared instance
45	*/
46	public static Activator getDefault() {
47	return plugin;
48	}
49
50	}