Skip to main content
aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to 'tests/junit/plugins/core/org.eclipse.papyrus.infra.core.tests/test')
-rw-r--r--tests/junit/plugins/core/org.eclipse.papyrus.infra.core.tests/test/org/eclipse/papyrus/infra/core/resource/Bug402525.ecore6
-rw-r--r--tests/junit/plugins/core/org.eclipse.papyrus.infra.core.tests/test/org/eclipse/papyrus/infra/core/resource/NestingTransactionalCommandStackTest.java513
-rw-r--r--tests/junit/plugins/core/org.eclipse.papyrus.infra.core.tests/test/org/eclipse/papyrus/infra/core/tests/AllTests.java6
3 files changed, 523 insertions, 2 deletions
diff --git a/tests/junit/plugins/core/org.eclipse.papyrus.infra.core.tests/test/org/eclipse/papyrus/infra/core/resource/Bug402525.ecore b/tests/junit/plugins/core/org.eclipse.papyrus.infra.core.tests/test/org/eclipse/papyrus/infra/core/resource/Bug402525.ecore
new file mode 100644
index 00000000000..8dea18de3e8
--- /dev/null
+++ b/tests/junit/plugins/core/org.eclipse.papyrus.infra.core.tests/test/org/eclipse/papyrus/infra/core/resource/Bug402525.ecore
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ecore:EPackage xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" name="bug402525" nsURI="http://www.eclipse.org/schema/Papyrus/tests/bug402525"
+ nsPrefix="bug">
+ <eClassifiers xsi:type="ecore:EClass" name="Foo"/>
+</ecore:EPackage>
diff --git a/tests/junit/plugins/core/org.eclipse.papyrus.infra.core.tests/test/org/eclipse/papyrus/infra/core/resource/NestingTransactionalCommandStackTest.java b/tests/junit/plugins/core/org.eclipse.papyrus.infra.core.tests/test/org/eclipse/papyrus/infra/core/resource/NestingTransactionalCommandStackTest.java
new file mode 100644
index 00000000000..c64b9923fb7
--- /dev/null
+++ b/tests/junit/plugins/core/org.eclipse.papyrus.infra.core.tests/test/org/eclipse/papyrus/infra/core/resource/NestingTransactionalCommandStackTest.java
@@ -0,0 +1,513 @@
+/*
+ * Copyright (c) 2014 CEA 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:
+ * Christian W. Damus (CEA) - Initial API and implementation
+ *
+ */
+package org.eclipse.papyrus.infra.core.resource;
+
+import static org.hamcrest.CoreMatchers.both;
+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.CoreMatchers.nullValue;
+import static org.hamcrest.CoreMatchers.sameInstance;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.fail;
+
+import java.net.URL;
+import java.util.concurrent.Callable;
+
+import org.eclipse.core.runtime.OperationCanceledException;
+import org.eclipse.emf.common.command.Command;
+import org.eclipse.emf.common.command.CommandStack;
+import org.eclipse.emf.common.notify.AdapterFactory;
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.ENamedElement;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EcoreFactory;
+import org.eclipse.emf.ecore.EcorePackage;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
+import org.eclipse.emf.edit.provider.ComposedAdapterFactory;
+import org.eclipse.emf.transaction.RecordingCommand;
+import org.eclipse.emf.transaction.TransactionalCommandStack;
+import org.eclipse.emf.transaction.TransactionalEditingDomain;
+import org.eclipse.emf.transaction.impl.TransactionalEditingDomainImpl;
+import org.hamcrest.BaseMatcher;
+import org.hamcrest.Description;
+import org.hamcrest.Matcher;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.google.common.base.Objects;
+
+
+/**
+ * Test suite for the {@link NestingTransactionalCommandStack} class.
+ */
+public class NestingTransactionalCommandStackTest {
+
+ // No API signatures but the most basic are required for nesting
+ private CommandStack fixture;
+
+ private TransactionalEditingDomain domain;
+
+ private ResourceSet rset;
+
+ private EPackage testPackage;
+
+ private EClass foo;
+
+ public NestingTransactionalCommandStackTest() {
+ super();
+ }
+
+ //
+ // Test cases
+ //
+
+ @Test
+ public void testCompleteUnnestedCommand() {
+ Callable<EAttribute> createAttribute = createAttribute();
+
+ int oldFeatureCount = foo.getEStructuralFeatures().size();
+
+ // Create two attributes
+ EAttribute attr1 = execute(createAttribute);
+ EAttribute attr2 = execute(createAttribute);
+ assertThat(foo.getEStructuralFeatures().size(), is(oldFeatureCount + 2));
+ assertThat(foo.getEStructuralFeatures(), hasItem(attr1));
+ assertThat(foo.getEStructuralFeatures(), hasItem(attr2));
+
+ // Undo only undoes one of them
+ Command undone = undo();
+ assertThat(foo.getEStructuralFeatures().size(), is(oldFeatureCount + 1));
+ assertThat(foo.getEStructuralFeatures(), hasItem(attr1));
+ assertThat(foo.getEStructuralFeatures(), not(hasItem(attr2)));
+
+ // Redo is sane
+ Command redone = redo();
+ assertThat(redone, sameInstance(undone));
+ assertThat(foo.getEStructuralFeatures().size(), is(oldFeatureCount + 2));
+ assertThat(foo.getEStructuralFeatures(), hasItem(attr1));
+ assertThat(foo.getEStructuralFeatures(), hasItem(attr2));
+ }
+
+ @Test
+ public void testCancelUnnestedCommand() {
+ Callable<EAttribute> createAttribute = createAttribute(2);
+
+ int oldFeatureCount = foo.getEStructuralFeatures().size();
+
+ // Try to create two attributes (second one cancels)
+ EAttribute attr1 = execute(createAttribute);
+ EAttribute attr2 = execute(createAttribute);
+ assertThat(attr2, nullValue());
+ assertThat(foo.getEStructuralFeatures().size(), is(oldFeatureCount + 1));
+ assertThat(foo.getEStructuralFeatures(), hasItem(attr1));
+ assertThat(foo.getEStructuralFeature("attribute2"), nullValue()); //$NON-NLS-1$
+
+ // Undo is sane
+ Command undone = undo();
+ assertThat(foo.getEStructuralFeatures().size(), is(oldFeatureCount));
+ assertThat(foo.getEStructuralFeatures(), not(hasItem(attr1)));
+ assertThat(foo.getEStructuralFeature("attribute2"), nullValue()); //$NON-NLS-1$
+
+ // Redo is sane
+ Command redone = redo();
+ assertThat(redone, sameInstance(undone));
+ assertThat(foo.getEStructuralFeatures().size(), is(oldFeatureCount + 1));
+ assertThat(foo.getEStructuralFeatures(), hasItem(attr1));
+ assertThat(foo.getEStructuralFeature("attribute2"), nullValue()); //$NON-NLS-1$
+ }
+
+ @Test
+ public void testCompleteNestedCommand() {
+ final int FEATURES = 2;
+ Callable<EClass> createClass = createClass(FEATURES);
+
+ int oldClassifierCount = testPackage.getEClassifiers().size();
+
+ EClass clas = execute(createClass);
+ assertThat(testPackage.getEClassifiers().size(), is(oldClassifierCount + 1));
+ assertThat(testPackage.getEClassifiers(), hasItem(clas));
+ assertThat(clas.getEStructuralFeatures().size(), is(FEATURES));
+ assertThat(clas.getEStructuralFeature("attribute1"), notNullValue()); //$NON-NLS-1$
+ assertThat(clas.getEStructuralFeature("attribute2"), notNullValue()); //$NON-NLS-1$
+
+ // Undo is sane and there is only one command to undo
+ Command undone = undo();
+ assertThat(fixture.canUndo(), is(false));
+ assertThat(testPackage.getEClassifiers().size(), is(oldClassifierCount));
+ assertThat(testPackage.getEClassifiers(), not(hasItem(clas)));
+
+ // Redo is sane
+ Command redone = redo();
+ assertThat(redone, sameInstance(undone));
+ assertThat(testPackage.getEClassifiers().size(), is(oldClassifierCount + 1));
+ assertThat(testPackage.getEClassifiers(), hasItem(clas));
+ assertThat(clas.getEStructuralFeatures().size(), is(FEATURES));
+ assertThat(clas.getEStructuralFeature("attribute1"), notNullValue()); //$NON-NLS-1$
+ assertThat(clas.getEStructuralFeature("attribute2"), notNullValue()); //$NON-NLS-1$
+ }
+
+ @Test
+ public void testCancelNestedCommand() {
+ final int FEATURES = 2;
+ Callable<EClass> createClass = createClass(FEATURES, 2, FEATURES);
+
+ int oldClassifierCount = testPackage.getEClassifiers().size();
+
+ // Try to create two classes (second one cancels)
+ EClass class1 = execute(createClass);
+ EClass class2 = execute(createClass);
+ assertThat(class2, nullValue());
+ assertThat(testPackage.getEClassifiers().size(), is(oldClassifierCount + 1));
+ assertThat(testPackage.getEClassifiers(), hasItem(class1));
+ assertThat(class1.getEStructuralFeatures().size(), is(FEATURES));
+ assertThat(class1.getEStructuralFeature("attribute1"), notNullValue()); //$NON-NLS-1$
+ assertThat(class1.getEStructuralFeature("attribute2"), notNullValue()); //$NON-NLS-1$
+
+ // Undo is sane and there is only one command to undo
+ Command undone = undo();
+ assertThat(fixture.canUndo(), is(false));
+ assertThat(testPackage.getEClassifiers().size(), is(oldClassifierCount));
+ assertThat(testPackage.getEClassifiers(), not(hasItem(class1)));
+
+ // Redo is sane
+ Command redone = redo();
+ assertThat(redone, sameInstance(undone));
+ assertThat(testPackage.getEClassifiers().size(), is(oldClassifierCount + 1));
+ assertThat(testPackage.getEClassifiers(), hasItem(class1));
+ assertThat(class1.getEStructuralFeatures().size(), is(FEATURES));
+ assertThat(class1.getEStructuralFeature("attribute1"), notNullValue()); //$NON-NLS-1$
+ assertThat(class1.getEStructuralFeature("attribute2"), notNullValue()); //$NON-NLS-1$
+ }
+
+ @Test
+ public void testCompleteTripleNestedCommand() {
+ final int CLASSES = 2;
+ final int FEATURES = 2;
+
+ Callable<EPackage> createPackage = createPackage(CLASSES, FEATURES);
+
+ int oldPackageCount = testPackage.getESubpackages().size();
+
+ EPackage pkg = execute(createPackage);
+ assertThat(testPackage.getESubpackages().size(), is(oldPackageCount + 1));
+ assertThat(testPackage.getESubpackages(), hasItem(pkg));
+ assertThat(pkg.getEClassifiers().size(), is(CLASSES));
+ assertThat(pkg.getEClassifiers(), hasItem(both(featureCount(FEATURES)).and(named("Class1")).and(hasFeature("attribute1")).and(hasFeature("attribute2")))); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ assertThat(pkg.getEClassifiers(), hasItem(both(featureCount(FEATURES)).and(named("Class2")).and(hasFeature("attribute1")).and(hasFeature("attribute2")))); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+
+ // Undo is sane and there is only one command to undo
+ Command undone = undo();
+ assertThat(fixture.canUndo(), is(false));
+ assertThat(testPackage.getESubpackages().size(), is(oldPackageCount));
+ assertThat(testPackage.getESubpackages(), not(hasItem(pkg)));
+ assertThat(pkg.getName(), nullValue());
+ assertThat(pkg.getEClassifiers().size(), is(0));
+ assertThat(pkg.getEClassifiers().size(), is(0));
+
+ // Redo is sane
+ Command redone = redo();
+ assertThat(redone, sameInstance(undone));
+ assertThat(fixture.canRedo(), is(false));
+ assertThat(testPackage.getESubpackages().size(), is(oldPackageCount + 1));
+ assertThat(testPackage.getESubpackages(), hasItem(pkg));
+ assertThat(pkg, named("package1")); //$NON-NLS-1$
+ assertThat(pkg.getEClassifiers().size(), is(CLASSES));
+ assertThat(pkg.getEClassifiers(), hasItem(both(featureCount(FEATURES)).and(named("Class1")).and(hasFeature("attribute1")).and(hasFeature("attribute2")))); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ assertThat(pkg.getEClassifiers(), hasItem(both(featureCount(FEATURES)).and(named("Class2")).and(hasFeature("attribute1")).and(hasFeature("attribute2")))); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ }
+
+ @Test
+ public void testCancelTripleNestedCommand() {
+ final int CLASSES = 2;
+ final int FEATURES = 2;
+
+ Callable<EPackage> createPackage = createPackage(CLASSES, FEATURES, 2, CLASSES, FEATURES);
+
+ int oldPackageCount = testPackage.getESubpackages().size();
+
+ // Try to create two packages (second one cancels)
+ EPackage pkg1 = execute(createPackage);
+ EPackage pkg2 = execute(createPackage);
+
+ // the first package is complete
+ assertThat(testPackage.getESubpackages().size(), is(oldPackageCount + 1));
+ assertThat(testPackage.getESubpackages(), hasItem(pkg1));
+ assertThat(pkg1, named("package1")); //$NON-NLS-1$
+ assertThat(pkg1.getEClassifiers().size(), is(CLASSES));
+ assertThat(pkg1.getEClassifiers(), hasItem(both(featureCount(FEATURES)).and(named("Class1")).and(hasFeature("attribute1")).and(hasFeature("attribute2")))); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ assertThat(pkg1.getEClassifiers(), hasItem(both(featureCount(FEATURES)).and(named("Class2")).and(hasFeature("attribute1")).and(hasFeature("attribute2")))); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+
+ // there is no second package
+ assertThat(pkg2, nullValue());
+
+ // Undo is sane and there is only one command to undo
+ Command undone = undo();
+ assertThat(fixture.canUndo(), is(false));
+ assertThat(testPackage.getESubpackages().size(), is(oldPackageCount));
+ assertThat(testPackage.getESubpackages(), not(hasItem(pkg1)));
+ assertThat(pkg1.getName(), nullValue());
+ assertThat(pkg1.getEClassifiers().size(), is(0));
+
+ // Redo is sane
+ Command redone = redo();
+ assertThat(fixture.canRedo(), is(false));
+ assertThat(redone, sameInstance(undone));
+ assertThat(testPackage.getESubpackages().size(), is(oldPackageCount + 1));
+ assertThat(testPackage.getESubpackages(), hasItem(pkg1));
+ assertThat(pkg1, named("package1")); //$NON-NLS-1$
+ assertThat(pkg1.getEClassifiers().size(), is(CLASSES));
+ assertThat(pkg1.getEClassifiers(), hasItem(both(featureCount(FEATURES)).and(named("Class1")).and(hasFeature("attribute1")).and(hasFeature("attribute2")))); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ assertThat(pkg1.getEClassifiers(), hasItem(both(featureCount(FEATURES)).and(named("Class2")).and(hasFeature("attribute1")).and(hasFeature("attribute2")))); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+ }
+
+ //
+ // Test framework
+ //
+
+ @Before
+ public void createFixture() {
+ rset = new ResourceSetImpl();
+ fixture = new NestingTransactionalCommandStack();
+ AdapterFactory adapterFactory = new ComposedAdapterFactory(ComposedAdapterFactory.Descriptor.Registry.INSTANCE);
+ domain = new TransactionalEditingDomainImpl(adapterFactory, (TransactionalCommandStack)fixture, rset);
+
+ URL testModelURL = getClass().getResource("bug402525.ecore"); //$NON-NLS-1$
+ Resource testModel = rset.getResource(URI.createURI(testModelURL.toExternalForm(), true), true);
+ testPackage = (EPackage)testModel.getContents().get(0);
+ foo = (EClass)testPackage.getEClassifier("Foo"); //$NON-NLS-1$
+ }
+
+ @After
+ public void destroyFixture() {
+ // This disposes the command stack for us
+ domain.dispose();
+ domain = null;
+ fixture = null;
+
+ dispose(rset);
+ rset = null;
+ }
+
+ void dispose(ResourceSet rset) {
+ for(Resource next : rset.getResources()) {
+ next.unload();
+ next.eAdapters().clear();
+ }
+
+ rset.getResources().clear();
+ rset.eAdapters().clear();
+ }
+
+ <V> V execute(final Callable<V> operation) {
+ class TestCommand extends RecordingCommand {
+
+ V result;
+
+ TestCommand() {
+ super(domain);
+ }
+
+ @Override
+ protected void doExecute() {
+ try {
+ result = operation.call();
+ } catch (OperationCanceledException e) {
+ // Pass it on
+ throw e;
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail("Uncaught exception in operation: " + e.getLocalizedMessage()); //$NON-NLS-1$
+ }
+ }
+ }
+
+ TestCommand command = new TestCommand();
+ fixture.execute(command);
+ return command.result;
+ }
+
+ Command undo() {
+ assertThat("Cannot undo", fixture.canUndo()); //$NON-NLS-1$
+ Command result = fixture.getUndoCommand();
+ fixture.undo();
+ return result;
+ }
+
+ Command redo() {
+ assertThat("Cannot redo", fixture.canRedo()); //$NON-NLS-1$
+ Command result = fixture.getRedoCommand();
+ fixture.redo();
+ return result;
+ }
+
+ Callable<EAttribute> createAttribute() {
+ return createAttribute(0);
+ }
+
+ Callable<EAttribute> createAttribute(int cancelOn) {
+ return createAttribute(foo, cancelOn);
+ }
+
+ Callable<EAttribute> createAttribute(final EClass owner, final int cancelOn) {
+ return new Callable<EAttribute>() {
+
+ int i = 0;
+
+ public EAttribute call() throws Exception {
+ String name = nextName();
+
+ EAttribute attr = EcoreFactory.eINSTANCE.createEAttribute();
+ owner.getEStructuralFeatures().add(attr);
+ attr.setName(name);
+ attr.setEType(EcorePackage.Literals.ESTRING);
+
+ checkCancel();
+
+ return attr;
+ }
+
+ private String nextName() {
+ i = i + 1;
+ return "attribute" + i; //$NON-NLS-1$
+ }
+
+ private void checkCancel() {
+ if(i == cancelOn) {
+ throw new OperationCanceledException();
+ }
+ }
+ };
+ }
+
+ Callable<EClass> createClass(int attributes) {
+ return createClass(attributes, 0, 0);
+ }
+
+ Callable<EClass> createClass(int attributes, int cancelOn, int cancelAttributesOn) {
+ return createClass(testPackage, attributes, cancelOn, cancelAttributesOn);
+ }
+
+ Callable<EClass> createClass(final EPackage owner, final int attributes, final int cancelOn, final int cancelAttributesOn) {
+ return new Callable<EClass>() {
+
+ int i = 0;
+
+ public EClass call() throws Exception {
+ String name = nextName();
+
+ EClass clas = EcoreFactory.eINSTANCE.createEClass();
+ owner.getEClassifiers().add(clas);
+ clas.setName(name);
+
+ Callable<?> createAttribute = createAttribute(clas, checkCancelAttributes());
+ for(int i = 0; i < attributes; i++) {
+ // Nested command
+ execute(createAttribute);
+ }
+
+ return clas;
+ }
+
+ private String nextName() {
+ i = i + 1;
+ return "Class" + i; //$NON-NLS-1$
+ }
+
+ private int checkCancelAttributes() {
+ return (i == cancelOn) ? cancelAttributesOn : 0;
+ }
+ };
+ }
+
+ Callable<EPackage> createPackage(int classes, int attributes) {
+ return createPackage(classes, attributes, 0, 0, 0);
+ }
+
+ Callable<EPackage> createPackage(final int classes, final int attributes, final int cancelOn, final int cancelClassesOn, final int cancelAttributesOn) {
+ return new Callable<EPackage>() {
+
+ int i = 0;
+
+ public EPackage call() throws Exception {
+ String name = nextName();
+
+ EPackage pkg = EcoreFactory.eINSTANCE.createEPackage();
+ testPackage.getESubpackages().add(pkg);
+ pkg.setName(name);
+
+ Callable<?> createClass = createClass(pkg, attributes, checkCancelClasses(), cancelAttributesOn);
+ for(int i = 0; i < classes; i++) {
+ // Nested command
+ execute(createClass);
+ }
+
+ return pkg;
+ }
+
+ private String nextName() {
+ i = i + 1;
+ return "package" + i; //$NON-NLS-1$
+ }
+
+ private int checkCancelClasses() {
+ return (i == cancelOn) ? cancelClassesOn : 0;
+ }
+ };
+ }
+
+ Matcher<ENamedElement> named(final String name) {
+ return new BaseMatcher<ENamedElement>() {
+
+ public void describeTo(Description desc) {
+ desc.appendText("is named \"").appendValue(name).appendText("\""); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ public boolean matches(Object o) {
+ return (o instanceof ENamedElement) && Objects.equal(((ENamedElement)o).getName(), name);
+ }
+ };
+ }
+
+ Matcher<EClass> featureCount(final int count) {
+ return new BaseMatcher<EClass>() {
+
+ public void describeTo(Description desc) {
+ desc.appendText("has ").appendValue(count).appendText(" features"); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ public boolean matches(Object o) {
+ return (o instanceof EClass) && (((EClass)o).getEStructuralFeatures().size() == count);
+ }
+ };
+ }
+
+ Matcher<EClass> hasFeature(final String name) {
+ return new BaseMatcher<EClass>() {
+
+ public void describeTo(Description desc) {
+ desc.appendText("has a \"").appendValue(name).appendText("\" feature"); //$NON-NLS-1$ //$NON-NLS-2$
+ }
+
+ public boolean matches(Object o) {
+ return (o instanceof EClass) && (((EClass)o).getEStructuralFeature(name) != null);
+ }
+ };
+ }
+}
diff --git a/tests/junit/plugins/core/org.eclipse.papyrus.infra.core.tests/test/org/eclipse/papyrus/infra/core/tests/AllTests.java b/tests/junit/plugins/core/org.eclipse.papyrus.infra.core.tests/test/org/eclipse/papyrus/infra/core/tests/AllTests.java
index 9670eb13bbc..1d389ba9ad7 100644
--- a/tests/junit/plugins/core/org.eclipse.papyrus.infra.core.tests/test/org/eclipse/papyrus/infra/core/tests/AllTests.java
+++ b/tests/junit/plugins/core/org.eclipse.papyrus.infra.core.tests/test/org/eclipse/papyrus/infra/core/tests/AllTests.java
@@ -1,5 +1,5 @@
/*****************************************************************************
- * Copyright (c) 2010, 2013 CEA LIST and others.
+ * Copyright (c) 2010, 2014 CEA LIST and others.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
@@ -9,6 +9,7 @@
* Contributors:
* Remi Schnekenburger (CEA LIST) remi.schnekenburger@cea.fr - Initial API and implementation
* Christian W. Damus (CEA LIST) - add test for AdapterUtils
+ * Christian W. Damus (CEA) - bug 402525
*****************************************************************************/
package org.eclipse.papyrus.infra.core.tests;
@@ -16,6 +17,7 @@ import org.eclipse.papyrus.infra.core.contentoutline.NestedEditorDelegatedOutlin
import org.eclipse.papyrus.infra.core.lifecycleevents.LifeCycleEventsProviderTest;
import org.eclipse.papyrus.infra.core.resource.AbstractModelWithSharedResourceTest;
import org.eclipse.papyrus.infra.core.resource.ModelSetTest;
+import org.eclipse.papyrus.infra.core.resource.NestingTransactionalCommandStackTest;
import org.eclipse.papyrus.infra.core.services.ComposedServiceTest;
import org.eclipse.papyrus.infra.core.services.ServicesRegistryTest;
import org.eclipse.papyrus.infra.core.utils.AdapterUtilsTest;
@@ -28,7 +30,7 @@ import org.junit.runners.Suite.SuiteClasses;
@RunWith(Suite.class)
@SuiteClasses({
// {oep.resource}
-ModelSetTest.class, AbstractModelWithSharedResourceTest.class,
+ModelSetTest.class, AbstractModelWithSharedResourceTest.class, NestingTransactionalCommandStackTest.class,
// {oep}.core.services
ComposedServiceTest.class, ServicesRegistryTest.class,
// {oep}.core.lifecycleevents

Back to the top