org.eclipse.gmf.tests.runtime.common.core/src/org/eclipse/gmf/tests/runtime/common/core/internal/command/AbstractCommandTest.java - gmf-runtime/org.eclipse.gmf-runtime - Git at Google

 /******************************************************************************
  * Copyright (c) 2006, 2007 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.common.core.internal.command;

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

 import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
 import junit.textui.TestRunner;

 import org.eclipse.core.commands.ExecutionException;
 import org.eclipse.core.commands.operations.IOperationHistory;
 import org.eclipse.core.commands.operations.IUndoContext;
 import org.eclipse.core.commands.operations.ObjectUndoContext;
 import org.eclipse.core.commands.operations.OperationHistoryFactory;
 import org.eclipse.core.commands.operations.UndoContext;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IWorkspaceRoot;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.IAdaptable;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.gmf.runtime.common.core.command.AbstractCommand;
 import org.eclipse.gmf.runtime.common.core.command.CommandResult;
 import org.eclipse.gmf.runtime.common.core.command.ICommand;

 /**
  * Tests the {@link AbstractCommand}.
  *
  * @author ldamus
  */
 public class AbstractCommandTest
     extends TestCase {

     private IOperationHistory history;
     private IProject project;

     public static void main(String[] args) {
         TestRunner.run(suite());
     }

     public static Test suite() {
         return new TestSuite(AbstractCommandTest.class);
     }

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

     protected void setUp()
         throws Exception {
         super.setUp();

         history = OperationHistoryFactory.getOperationHistory();

         IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
         project = root.getProject("AbstractCommandTest"); //$NON-NLS-1$
         project.create(null);
         project.open(null);
     }

     protected void tearDown()
         throws Exception {
         super.tearDown();

         project.close(new NullProgressMonitor());
         project.delete(true, true, new NullProgressMonitor());
         project = null;
         history = null;
     }

     private List getFiles(String str) {
         IFile file = project.getFile(str);
         return Collections.singletonList(file);
     }

     /**
      * Tests that commands can be executed, undone and redone through the
      * operation history.
      */
     public void test_execute_undo_redo() {
         String name = "test_execute_undo_redo"; //$NON-NLS-1$
         TestCommand c = new TestCommand(name, null);
         IUndoContext ctx = new ObjectUndoContext(this);

         try {
             c.addContext(ctx);
             history.execute(c, new NullProgressMonitor(), null);
         } catch (ExecutionException e) {
             e.printStackTrace();
             fail("Should not have thrown: " + e.getLocalizedMessage()); //$NON-NLS-1$
         }

         c.assertExecuted();

         try {
             assertTrue(history.canUndo(ctx));
             history.undo(ctx, new NullProgressMonitor(), null);
         } catch (ExecutionException e) {
             e.printStackTrace();
             fail("Should not have thrown: " + e.getLocalizedMessage()); //$NON-NLS-1$
         }

         c.assertUndone();

         try {
             assertTrue(history.canRedo(ctx));
             history.redo(ctx, new NullProgressMonitor(), null);
         } catch (ExecutionException e) {
             e.printStackTrace();
             fail("Should not have thrown: " + e.getLocalizedMessage()); //$NON-NLS-1$
         }

         c.assertRedone();
     }

     /**
      * Tests that composing two commands results in a command that combines the
      * contexts and affected files from both children.
      */
     public void test_compose() {
         String name = "test_compose"; //$NON-NLS-1$

         IUndoContext ctx1 = new UndoContext();
         IUndoContext ctx2 = new UndoContext();

         ICommand c1 = new TestCommand(name, getFiles("compose1")); //$NON-NLS-1$
         c1.addContext(ctx1);

         ICommand c2 = new TestCommand(name, getFiles("compose2")); //$NON-NLS-1$
         c2.addContext(ctx2);

         List threeFiles = new ArrayList(3);
         threeFiles.addAll(c1.getAffectedFiles());
         threeFiles.addAll(c2.getAffectedFiles());
         threeFiles.add(getFiles("compose3")); //$NON-NLS-1$
         ICommand c3 = new TestCommand(name, threeFiles);

         ICommand composition = c1.compose(c2).compose(c3);

         List affectedFiles = composition.getAffectedFiles();
         assertTrue(affectedFiles.containsAll(c1.getAffectedFiles()));
         assertTrue(affectedFiles.containsAll(c2.getAffectedFiles()));

         // should be no duplicates
         assertEquals(3, affectedFiles.size());

         List contexts = Arrays.asList(composition.getContexts());
         assertTrue(contexts.contains(ctx1));
         assertTrue(contexts.contains(ctx2));
     }

     /**
      * Tests that the reduction of an AbstractCommand returns itself.
      */
     public void test_reduce() {
         String name = "test_reduce"; //$NON-NLS-1$

         ICommand c = new TestCommand(name, null);
         ICommand reduction = c.reduce();

         assertSame(c, reduction);
     }

     /**
      * Tests that the affected files set in the command constructor are
      * available through the getAffectedFiles() method.
      */
     public void test_getAffectedFiles() {
         String fixtureName = "test_getAffectedFiles"; //$NON-NLS-1$

         // no affected files
         ICommand c = new TestCommand(fixtureName, null);
         assertTrue(c.getAffectedFiles().isEmpty());

         // an affected file
         List affectedFiles = getFiles("null:/AbstractCommandTest"); //$NON-NLS-1$

         c = new TestCommand(fixtureName, affectedFiles);

         assertEquals(affectedFiles.size(), c.getAffectedFiles().size());
         assertTrue(c.getAffectedFiles().containsAll(affectedFiles));
     }

     /**
 	 * Verifies that no exceptions are thrown when a command is executed, undone
 	 * or redone that has no command result.
 	 */
     public void test_noCommandResult_146064() {
     	 String name = "test_noCommandResult_146064"; //$NON-NLS-1$
          TestCommand c = new TestCommandNoResults(name, null);
          IUndoContext ctx = new ObjectUndoContext(this);

          try {
              c.addContext(ctx);
              history.execute(c, new NullProgressMonitor(), null);
          } catch (ExecutionException e) {
              e.printStackTrace();
              fail("Should not have thrown: " + e.getLocalizedMessage()); //$NON-NLS-1$
          }

          c.assertExecuted();

          try {
              assertTrue(history.canUndo(ctx));
              history.undo(ctx, new NullProgressMonitor(), null);
          } catch (ExecutionException e) {
              e.printStackTrace();
              fail("Should not have thrown: " + e.getLocalizedMessage()); //$NON-NLS-1$
          }

          c.assertUndone();

          try {
              assertTrue(history.canRedo(ctx));
              history.redo(ctx, new NullProgressMonitor(), null);
          } catch (ExecutionException e) {
              e.printStackTrace();
              fail("Should not have thrown: " + e.getLocalizedMessage()); //$NON-NLS-1$
          }

          c.assertRedone();
     }

     /**
 	 * Verifies that subclasses of AbstractCommand don't need to check whether
 	 * or not the progress monitor input to #doExecute, #doUndo and #doRedo is
 	 * null.
 	 */
 	public void test_nullMonitor_149057() {
 		TestCommandWithProgress c = new TestCommandWithProgress(
 				"test_nullMonitor_149057");  //$NON-NLS-1$

 		IUndoContext ctx = new ObjectUndoContext(this);

         try {
             c.addContext(ctx);
             history.execute(c, null, null);
         } catch (ExecutionException e) {
             e.printStackTrace();
             fail("Should not have thrown: " + e.getCause()); //$NON-NLS-1$
         }

         c.assertExecuted();

         try {
             assertTrue(history.canUndo(ctx));
             history.undo(ctx, null, null);
         } catch (ExecutionException e) {
             e.printStackTrace();
             fail("Should not have thrown: " + e.getCause()); //$NON-NLS-1$
         }

         c.assertUndone();

         try {
             assertTrue(history.canRedo(ctx));
             history.redo(ctx, null, null);
         } catch (ExecutionException e) {
             e.printStackTrace();
             fail("Should not have thrown: " + e.getCause()); //$NON-NLS-1$
         }

         c.assertRedone();
 	}

     //
     // TEST FIXTURES
     //

     protected static class TestCommand
         extends AbstractCommand {

         private static final String EXECUTED = "executed"; //$NON-NLS-1$

         private static final String UNDONE = "undone"; //$NON-NLS-1$

         private static final String REDONE = "redone"; //$NON-NLS-1$

         protected boolean executed;

         protected boolean undone;

         protected boolean redone;

         public TestCommand(String label, List affectedFiles) {
             super(label, affectedFiles);
         }

         protected CommandResult doExecuteWithResult(
                 IProgressMonitor progressMonitor, IAdaptable info)
             throws ExecutionException {
             executed = true;
             undone = false;
             redone = false;
             return CommandResult.newOKCommandResult(EXECUTED);
         }

         protected CommandResult doRedoWithResult(
                 IProgressMonitor progressMonitor, IAdaptable info)
             throws ExecutionException {
             executed = false;
             undone = false;
             redone = true;
             return CommandResult.newOKCommandResult(REDONE);
         }

         protected CommandResult doUndoWithResult(
                 IProgressMonitor progressMonitor, IAdaptable info)
             throws ExecutionException {
             executed = false;
             undone = true;
             redone = false;
             return CommandResult.newOKCommandResult(UNDONE);
         }

         public void assertExecuted() {
             assertTrue(executed);
             assertFalse(undone);
             assertFalse(redone);
             assertEquals(IStatus.OK, getCommandResult().getStatus()
                 .getSeverity());
             assertSame(EXECUTED, getCommandResult().getReturnValue());
         }

         public void assertUndone() {
             assertTrue(undone);
             assertFalse(executed);
             assertFalse(redone);
             assertEquals(IStatus.OK, getCommandResult().getStatus()
                 .getSeverity());
             assertSame(UNDONE, getCommandResult().getReturnValue());
         }

         public void assertRedone() {
             assertTrue(redone);
             assertFalse(undone);
             assertFalse(executed);
             assertEquals(IStatus.OK, getCommandResult().getStatus()
                 .getSeverity());
             assertSame(REDONE, getCommandResult().getReturnValue());
         }
     }

     protected static class TestCommandNoResults extends TestCommand {

 		public TestCommandNoResults(String label, List affectedFiles) {
 			super(label, affectedFiles);
 		}

 		protected CommandResult doExecuteWithResult(
 				IProgressMonitor progressMonitor, IAdaptable info)
 				throws ExecutionException {

 			super.doExecuteWithResult(progressMonitor, info);
 			return null;
 		}

 		protected CommandResult doRedoWithResult(
 				IProgressMonitor progressMonitor, IAdaptable info)
 				throws ExecutionException {
 			super.doRedoWithResult(progressMonitor, info);
 			return null;
 		}

 		protected CommandResult doUndoWithResult(
 				IProgressMonitor progressMonitor, IAdaptable info)
 				throws ExecutionException {
 			super.doUndoWithResult(progressMonitor, info);
 			return null;
 		}

         public void assertExecuted() {
             assertTrue(executed);
             assertFalse(undone);
             assertFalse(redone);
             assertNull(getCommandResult());
         }

         public void assertUndone() {
             assertTrue(undone);
             assertFalse(executed);
             assertFalse(redone);
             assertNull(getCommandResult());
         }

         public void assertRedone() {
             assertTrue(redone);
             assertFalse(undone);
             assertFalse(executed);
             assertNull(getCommandResult());
         }
 	}

     protected static class TestCommandWithProgress extends TestCommand {

 		public TestCommandWithProgress(String label) {
 			super(label, null);
 		}

 		protected CommandResult doExecuteWithResult(
 				IProgressMonitor progressMonitor, IAdaptable info)
 				throws ExecutionException {
 			progressMonitor.worked(1);
 			return super.doExecuteWithResult(progressMonitor, info);
 		}

 		protected CommandResult doRedoWithResult(
 				IProgressMonitor progressMonitor, IAdaptable info)
 				throws ExecutionException {
 			progressMonitor.worked(1);
 			return super.doRedoWithResult(progressMonitor, info);
 		}

 		protected CommandResult doUndoWithResult(
 				IProgressMonitor progressMonitor, IAdaptable info)
 				throws ExecutionException {
 			progressMonitor.worked(1);
 			return super.doUndoWithResult(progressMonitor, info);
 		}
 	}

 }
	/******************************************************************************
	* Copyright (c) 2006, 2007 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.common.core.internal.command;

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

	import junit.framework.Test;
	import junit.framework.TestCase;
	import junit.framework.TestSuite;
	import junit.textui.TestRunner;

	import org.eclipse.core.commands.ExecutionException;
	import org.eclipse.core.commands.operations.IOperationHistory;
	import org.eclipse.core.commands.operations.IUndoContext;
	import org.eclipse.core.commands.operations.ObjectUndoContext;
	import org.eclipse.core.commands.operations.OperationHistoryFactory;
	import org.eclipse.core.commands.operations.UndoContext;
	import org.eclipse.core.resources.IFile;
	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.resources.IWorkspaceRoot;
	import org.eclipse.core.resources.ResourcesPlugin;
	import org.eclipse.core.runtime.IAdaptable;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.NullProgressMonitor;
	import org.eclipse.gmf.runtime.common.core.command.AbstractCommand;
	import org.eclipse.gmf.runtime.common.core.command.CommandResult;
	import org.eclipse.gmf.runtime.common.core.command.ICommand;

	/**
	* Tests the {@link AbstractCommand}.
	*
	* @author ldamus
	*/
	public class AbstractCommandTest
	extends TestCase {

	private IOperationHistory history;
	private IProject project;

	public static void main(String[] args) {
	TestRunner.run(suite());
	}

	public static Test suite() {
	return new TestSuite(AbstractCommandTest.class);
	}

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

	protected void setUp()
	throws Exception {
	super.setUp();

	history = OperationHistoryFactory.getOperationHistory();

	IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
	project = root.getProject("AbstractCommandTest"); //$NON-NLS-1$
	project.create(null);
	project.open(null);
	}

	protected void tearDown()
	throws Exception {
	super.tearDown();

	project.close(new NullProgressMonitor());
	project.delete(true, true, new NullProgressMonitor());
	project = null;
	history = null;
	}

	private List getFiles(String str) {
	IFile file = project.getFile(str);
	return Collections.singletonList(file);
	}

	/**
	* Tests that commands can be executed, undone and redone through the
	* operation history.
	*/
	public void test_execute_undo_redo() {
	String name = "test_execute_undo_redo"; //$NON-NLS-1$
	TestCommand c = new TestCommand(name, null);
	IUndoContext ctx = new ObjectUndoContext(this);

	try {
	c.addContext(ctx);
	history.execute(c, new NullProgressMonitor(), null);
	} catch (ExecutionException e) {
	e.printStackTrace();
	fail("Should not have thrown: " + e.getLocalizedMessage()); //$NON-NLS-1$
	}

	c.assertExecuted();

	try {
	assertTrue(history.canUndo(ctx));
	history.undo(ctx, new NullProgressMonitor(), null);
	} catch (ExecutionException e) {
	e.printStackTrace();
	fail("Should not have thrown: " + e.getLocalizedMessage()); //$NON-NLS-1$
	}

	c.assertUndone();

	try {
	assertTrue(history.canRedo(ctx));
	history.redo(ctx, new NullProgressMonitor(), null);
	} catch (ExecutionException e) {
	e.printStackTrace();
	fail("Should not have thrown: " + e.getLocalizedMessage()); //$NON-NLS-1$
	}

	c.assertRedone();
	}

	/**
	* Tests that composing two commands results in a command that combines the
	* contexts and affected files from both children.
	*/
	public void test_compose() {
	String name = "test_compose"; //$NON-NLS-1$

	IUndoContext ctx1 = new UndoContext();
	IUndoContext ctx2 = new UndoContext();

	ICommand c1 = new TestCommand(name, getFiles("compose1")); //$NON-NLS-1$
	c1.addContext(ctx1);

	ICommand c2 = new TestCommand(name, getFiles("compose2")); //$NON-NLS-1$
	c2.addContext(ctx2);

	List threeFiles = new ArrayList(3);
	threeFiles.addAll(c1.getAffectedFiles());
	threeFiles.addAll(c2.getAffectedFiles());
	threeFiles.add(getFiles("compose3")); //$NON-NLS-1$
	ICommand c3 = new TestCommand(name, threeFiles);

	ICommand composition = c1.compose(c2).compose(c3);

	List affectedFiles = composition.getAffectedFiles();
	assertTrue(affectedFiles.containsAll(c1.getAffectedFiles()));
	assertTrue(affectedFiles.containsAll(c2.getAffectedFiles()));

	// should be no duplicates
	assertEquals(3, affectedFiles.size());

	List contexts = Arrays.asList(composition.getContexts());
	assertTrue(contexts.contains(ctx1));
	assertTrue(contexts.contains(ctx2));
	}

	/**
	* Tests that the reduction of an AbstractCommand returns itself.
	*/
	public void test_reduce() {
	String name = "test_reduce"; //$NON-NLS-1$

	ICommand c = new TestCommand(name, null);
	ICommand reduction = c.reduce();

	assertSame(c, reduction);
	}

	/**
	* Tests that the affected files set in the command constructor are
	* available through the getAffectedFiles() method.
	*/
	public void test_getAffectedFiles() {
	String fixtureName = "test_getAffectedFiles"; //$NON-NLS-1$

	// no affected files
	ICommand c = new TestCommand(fixtureName, null);
	assertTrue(c.getAffectedFiles().isEmpty());

	// an affected file
	List affectedFiles = getFiles("null:/AbstractCommandTest"); //$NON-NLS-1$

	c = new TestCommand(fixtureName, affectedFiles);

	assertEquals(affectedFiles.size(), c.getAffectedFiles().size());
	assertTrue(c.getAffectedFiles().containsAll(affectedFiles));
	}

	/**
	* Verifies that no exceptions are thrown when a command is executed, undone
	* or redone that has no command result.
	*/
	public void test_noCommandResult_146064() {
	String name = "test_noCommandResult_146064"; //$NON-NLS-1$
	TestCommand c = new TestCommandNoResults(name, null);
	IUndoContext ctx = new ObjectUndoContext(this);

	try {
	c.addContext(ctx);
	history.execute(c, new NullProgressMonitor(), null);
	} catch (ExecutionException e) {
	e.printStackTrace();
	fail("Should not have thrown: " + e.getLocalizedMessage()); //$NON-NLS-1$
	}

	c.assertExecuted();

	try {
	assertTrue(history.canUndo(ctx));
	history.undo(ctx, new NullProgressMonitor(), null);
	} catch (ExecutionException e) {
	e.printStackTrace();
	fail("Should not have thrown: " + e.getLocalizedMessage()); //$NON-NLS-1$
	}

	c.assertUndone();

	try {
	assertTrue(history.canRedo(ctx));
	history.redo(ctx, new NullProgressMonitor(), null);
	} catch (ExecutionException e) {
	e.printStackTrace();
	fail("Should not have thrown: " + e.getLocalizedMessage()); //$NON-NLS-1$
	}

	c.assertRedone();
	}

	/**
	* Verifies that subclasses of AbstractCommand don't need to check whether
	* or not the progress monitor input to #doExecute, #doUndo and #doRedo is
	* null.
	*/
	public void test_nullMonitor_149057() {
	TestCommandWithProgress c = new TestCommandWithProgress(
	"test_nullMonitor_149057"); //$NON-NLS-1$

	IUndoContext ctx = new ObjectUndoContext(this);

	try {
	c.addContext(ctx);
	history.execute(c, null, null);
	} catch (ExecutionException e) {
	e.printStackTrace();
	fail("Should not have thrown: " + e.getCause()); //$NON-NLS-1$
	}

	c.assertExecuted();

	try {
	assertTrue(history.canUndo(ctx));
	history.undo(ctx, null, null);
	} catch (ExecutionException e) {
	e.printStackTrace();
	fail("Should not have thrown: " + e.getCause()); //$NON-NLS-1$
	}

	c.assertUndone();

	try {
	assertTrue(history.canRedo(ctx));
	history.redo(ctx, null, null);
	} catch (ExecutionException e) {
	e.printStackTrace();
	fail("Should not have thrown: " + e.getCause()); //$NON-NLS-1$
	}

	c.assertRedone();
	}

	//
	// TEST FIXTURES
	//

	protected static class TestCommand
	extends AbstractCommand {

	private static final String EXECUTED = "executed"; //$NON-NLS-1$

	private static final String UNDONE = "undone"; //$NON-NLS-1$

	private static final String REDONE = "redone"; //$NON-NLS-1$

	protected boolean executed;

	protected boolean undone;

	protected boolean redone;

	public TestCommand(String label, List affectedFiles) {
	super(label, affectedFiles);
	}

	protected CommandResult doExecuteWithResult(
	IProgressMonitor progressMonitor, IAdaptable info)
	throws ExecutionException {
	executed = true;
	undone = false;
	redone = false;
	return CommandResult.newOKCommandResult(EXECUTED);
	}

	protected CommandResult doRedoWithResult(
	IProgressMonitor progressMonitor, IAdaptable info)
	throws ExecutionException {
	executed = false;
	undone = false;
	redone = true;
	return CommandResult.newOKCommandResult(REDONE);
	}

	protected CommandResult doUndoWithResult(
	IProgressMonitor progressMonitor, IAdaptable info)
	throws ExecutionException {
	executed = false;
	undone = true;
	redone = false;
	return CommandResult.newOKCommandResult(UNDONE);
	}

	public void assertExecuted() {
	assertTrue(executed);
	assertFalse(undone);
	assertFalse(redone);
	assertEquals(IStatus.OK, getCommandResult().getStatus()
	.getSeverity());
	assertSame(EXECUTED, getCommandResult().getReturnValue());
	}

	public void assertUndone() {
	assertTrue(undone);
	assertFalse(executed);
	assertFalse(redone);
	assertEquals(IStatus.OK, getCommandResult().getStatus()
	.getSeverity());
	assertSame(UNDONE, getCommandResult().getReturnValue());
	}

	public void assertRedone() {
	assertTrue(redone);
	assertFalse(undone);
	assertFalse(executed);
	assertEquals(IStatus.OK, getCommandResult().getStatus()
	.getSeverity());
	assertSame(REDONE, getCommandResult().getReturnValue());
	}
	}

	protected static class TestCommandNoResults extends TestCommand {

	public TestCommandNoResults(String label, List affectedFiles) {
	super(label, affectedFiles);
	}

	protected CommandResult doExecuteWithResult(
	IProgressMonitor progressMonitor, IAdaptable info)
	throws ExecutionException {

	super.doExecuteWithResult(progressMonitor, info);
	return null;
	}

	protected CommandResult doRedoWithResult(
	IProgressMonitor progressMonitor, IAdaptable info)
	throws ExecutionException {
	super.doRedoWithResult(progressMonitor, info);
	return null;
	}

	protected CommandResult doUndoWithResult(
	IProgressMonitor progressMonitor, IAdaptable info)
	throws ExecutionException {
	super.doUndoWithResult(progressMonitor, info);
	return null;
	}

	public void assertExecuted() {
	assertTrue(executed);
	assertFalse(undone);
	assertFalse(redone);
	assertNull(getCommandResult());
	}

	public void assertUndone() {
	assertTrue(undone);
	assertFalse(executed);
	assertFalse(redone);
	assertNull(getCommandResult());
	}

	public void assertRedone() {
	assertTrue(redone);
	assertFalse(undone);
	assertFalse(executed);
	assertNull(getCommandResult());
	}
	}

	protected static class TestCommandWithProgress extends TestCommand {

	public TestCommandWithProgress(String label) {
	super(label, null);
	}

	protected CommandResult doExecuteWithResult(
	IProgressMonitor progressMonitor, IAdaptable info)
	throws ExecutionException {
	progressMonitor.worked(1);
	return super.doExecuteWithResult(progressMonitor, info);
	}

	protected CommandResult doRedoWithResult(
	IProgressMonitor progressMonitor, IAdaptable info)
	throws ExecutionException {
	progressMonitor.worked(1);
	return super.doRedoWithResult(progressMonitor, info);
	}

	protected CommandResult doUndoWithResult(
	IProgressMonitor progressMonitor, IAdaptable info)
	throws ExecutionException {
	progressMonitor.worked(1);
	return super.doUndoWithResult(progressMonitor, info);
	}
	}

	}