///*******************************************************************************
// * Copyright (c) 2005, 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.ui.tests.operations;
//
//import java.io.BufferedReader;
//import java.io.ByteArrayInputStream;
//import java.io.IOException;
//import java.io.InputStream;
//import java.io.InputStreamReader;
//import java.net.URI;
//import java.text.MessageFormat;
//import java.util.ArrayList;
//import java.util.HashMap;
//import java.util.HashSet;
//import java.util.List;
//import java.util.Map;
//import java.util.Set;
//
//import org.eclipse.core.commands.ExecutionException;
//import org.eclipse.core.commands.operations.IOperationHistory;
//import org.eclipse.core.commands.operations.IUndoContext;
//import org.eclipse.core.filesystem.EFS;
//import org.eclipse.core.filesystem.IFileStore;
//import org.eclipse.core.filesystem.URIUtil;
//import org.eclipse.core.resources.IFile;
//import org.eclipse.core.resources.IFolder;
//import org.eclipse.core.resources.IMarker;
//import org.eclipse.core.resources.IProject;
//import org.eclipse.core.resources.IProjectDescription;
//import org.eclipse.core.resources.IResource;
//import org.eclipse.core.resources.IWorkspace;
//import org.eclipse.core.resources.IWorkspaceRoot;
//import org.eclipse.core.resources.ResourcesPlugin;
//import org.eclipse.core.runtime.CoreException;
//import org.eclipse.core.runtime.IPath;
//import org.eclipse.core.runtime.IProgressMonitor;
//import org.eclipse.core.runtime.IStatus;
//import org.eclipse.core.runtime.Path;
//import org.eclipse.core.tests.harness.FileSystemHelper;
//import org.eclipse.ui.PlatformUI;
//import org.eclipse.ui.ide.undo.AbstractWorkspaceOperation;
//import org.eclipse.ui.ide.undo.CopyProjectOperation;
//import org.eclipse.ui.ide.undo.CopyResourcesOperation;
//import org.eclipse.ui.ide.undo.CreateFileOperation;
//import org.eclipse.ui.ide.undo.CreateFolderOperation;
//import org.eclipse.ui.ide.undo.CreateMarkersOperation;
//import org.eclipse.ui.ide.undo.CreateProjectOperation;
//import org.eclipse.ui.ide.undo.DeleteMarkersOperation;
//import org.eclipse.ui.ide.undo.DeleteResourcesOperation;
//import org.eclipse.ui.ide.undo.MoveProjectOperation;
//import org.eclipse.ui.ide.undo.MoveResourcesOperation;
//import org.eclipse.ui.ide.undo.UpdateMarkersOperation;
//import org.eclipse.ui.internal.operations.AdvancedValidationUserApprover;
//import org.eclipse.ui.tests.harness.util.UITestCase;
//
///**
// * Tests the undo of various workspace operations. Uses the following workspace
// * structure to perform the tests
// * 
// * <pre>
// *  TEST_PROJECT_NAME
// *  **TEST_FOLDER_NAME
// *  ****TEST_SUBFOLDER_NAME
// *  ******TEST_FILEINSUBFOLDER_NAME 
// *  ****TEST_EMPTYFILE_NAME
// *  ****TEST_RANDOMFILE_NAME
// *  ****TEST_LINKEDFILE_NAME (linked to random location)
// *  ****TEST_LINKEDFOLDER_NAME (linked to random location)
// *  **TEST_FILEINPROJECT_NAME 
// *  TEST_TARGETPROJECT_NAME
// * </pre>
// * 
// * @since 3.3
// */
//public class WorkspaceOperationsTests extends UITestCase {
//
//	IProject testProject, targetProject;
//
//	IFolder testFolder, testSubFolder, testLinkedFolder;
//
//	IFile emptyTestFile, testFileWithContent, testLinkedFile,
//			testFileInSubFolder, testFileInProject;
//
//	private final Set storesToDelete = new HashSet();
//
//	IOperationHistory history;
//
//	IUndoContext context;
//
//	private static Map initialAttributes = new HashMap();
//	static {
//		initialAttributes.put("Attr1", "Attr1 1.0");
//		initialAttributes.put("Attr2", "Attr2 1.0");
//		initialAttributes.put("Attr3", "Attr3 1.0");
//		initialAttributes.put("Attr4", "Attr4 1.0");
//		initialAttributes.put("Attr5", "Attr5 1.0");
//		initialAttributes.put("Attr6", "Attr6 1.0");
//	};
//
//	private static Map updatedAttributes = new HashMap();
//	static {
//		updatedAttributes.put("Attr1", "Attr1 1.1");
//		updatedAttributes.put("Attr2", "Attr2 1.1");
//		updatedAttributes.put("Attr3", "Attr3 1.1");
//		updatedAttributes.put("Attr4", "Attr4 1.1");
//		updatedAttributes.put("Attr5", "Attr5 1.1");
//		updatedAttributes.put("Attr7", "Attr7 1.0");
//	};
//
//	private static Map mergedUpdatedAttributes = new HashMap();
//	static {
//		mergedUpdatedAttributes.put("Attr1", "Attr1 1.1");
//		mergedUpdatedAttributes.put("Attr2", "Attr2 1.1");
//		mergedUpdatedAttributes.put("Attr3", "Attr3 1.1");
//		mergedUpdatedAttributes.put("Attr4", "Attr4 1.1");
//		mergedUpdatedAttributes.put("Attr5", "Attr5 1.1");
//		mergedUpdatedAttributes.put("Attr6", "Attr6 1.0");
//		mergedUpdatedAttributes.put("Attr7", "Attr7 1.0");
//	};
//
//	private static List fileNameExcludes = new ArrayList();
//	static {
//		fileNameExcludes.add(".project");
//	};
//
//	private static String CUSTOM_TYPE = "TestMarkerType";
//
//	private static String FILE_CONTENTS_EMPTY = "";
//
//	private static String TEST_PROJECT_NAME = "WorkspaceOperationsTests_Project";
//
//	private static String TEST_TARGET_PROJECT_NAME = "WorkspaceOperationsTests_MoveCopyTarget";
//
//	private static String TEST_FOLDER_NAME = "WorkspaceOperationsTests_Folder";
//
//	private static String TEST_SUBFOLDER_NAME = "WorkspaceOperationsTests_SubFolder";
//
//	private static String TEST_LINKEDFOLDER_NAME = "WorkspaceOperationsTests_LinkedFolder";
//
//	private static String TEST_LINKEDFILE_NAME = "WorkspaceOperationTests_LinkedFile";
//
//	private static String TEST_EMPTYFILE_NAME = "WorkspaceOperationsTests_EmptyFile";
//
//	private static String TEST_RANDOMFILE_NAME = "WorkspaceOperationsTests_RandomContentFile.txt";
//
//	private static String TEST_FILEINPROJECT_NAME = "WorkspaceOperationsTests_FileInProject";
//
//	private static String TEST_FILEINSUBFOLDER_NAME = "WorkspaceOperationsTests_FileInSubFolder";
//
//	private static String TEST_NEWPROJECT_NAME = "WorkspaceOperationTests_NewProject";
//
//	private static String TEST_NEWFOLDER_NAME = "WorkspaceOperationTests_NewFolder";
//
//	private static String TEST_NEWFILE_NAME = "WorkspaceOperationTests_NewFile";
//
//	private static String TEST_NEWNESTEDFOLDER_NAME = "scooby/dooby/doo/WorkspaceOperationTests_NewFolder";
//
//	private static String TEST_NEWNESTEDFILE_NAME = "scooby/dooby/doo/WorkspaceOperationTests_NewFile";
//
//	// Insider knowledge of WorkspaceUndoMonitor's change threshhold
//	private static int NUM_CHANGES = 10;
//
//	class FileSnapshot extends ResourceSnapshot {
//		String content;
//
//		URI location;
//
//		MarkerSnapshot[] markerSnapshots;
//
//		FileSnapshot(IFile file) throws CoreException {
//			content = readContent(file);
//			name = file.getName();
//			if (file.isLinked()) {
//				location = file.getLocationURI();
//			}
//			IMarker[] markers = file.findMarkers(null, true,
//					IResource.DEPTH_INFINITE);
//			markerSnapshots = new MarkerSnapshot[markers.length];
//			for (int i = 0; i < markers.length; i++) {
//				markerSnapshots[i] = new MarkerSnapshot(markers[i]);
//			}
//		}
//
//		boolean isValid(IResource parent) throws CoreException {
//			IResource resource = getWorkspaceRoot().findMember(
//					parent.getFullPath().append(name));
//			if (resource == null || !(resource instanceof IFile)) {
//				return false;
//			}
//			IFile file = (IFile) resource;
//			boolean contentMatch = readContent(file).equals(content);
//			if (file.isLinked()) {
//				contentMatch = contentMatch
//						&& file.getLocationURI().equals(location);
//			}
//			if (!contentMatch) {
//				return false;
//			}
//			for (int i = 0; i < markerSnapshots.length; i++) {
//				if (!markerSnapshots[i].existsOn(resource)) {
//					return false;
//				}
//			}
//			return true;
//		}
//	}
//
//	class FolderSnapshot extends ResourceSnapshot {
//		URI location;
//
//		ResourceSnapshot[] memberSnapshots;
//
//		FolderSnapshot(IFolder folder) throws CoreException {
//			name = folder.getName();
//			if (folder.isLinked()) {
//				location = folder.getLocationURI();
//			}
//			IResource[] members = folder.members();
//			memberSnapshots = new ResourceSnapshot[members.length];
//			for (int i = 0; i < members.length; i++) {
//				memberSnapshots[i] = snapshotFromResource(members[i]);
//			}
//		}
//
//		boolean isValid(IResource parent) throws CoreException {
//			IResource resource = getWorkspaceRoot().findMember(
//					parent.getFullPath().append(name));
//			if (resource == null || !(resource instanceof IFolder)) {
//				return false;
//			}
//			IFolder folder = (IFolder) resource;
//			if (folder.isLinked()) {
//				if (!folder.getLocationURI().equals(location)) {
//					return false;
//				}
//			}
//			for (int i = 0; i < memberSnapshots.length; i++) {
//				if (!fileNameExcludes.contains(memberSnapshots[i].name)) {
//					if (!memberSnapshots[i].isValid(folder)) {
//						return false;
//					}
//				}
//			}
//			return true;
//		}
//	}
//
//	class MarkerSnapshot {
//		String type;
//
//		Map attributes;
//
//		MarkerSnapshot(IMarker marker) throws CoreException {
//			type = marker.getType();
//			attributes = marker.getAttributes();
//		}
//
//		boolean existsOn(IResource resource) throws CoreException {
//			// comparison is based on equality of attributes, since id will
//			// change on create/delete/recreate sequence
//			IMarker[] markers = resource.findMarkers(type, false,
//					IResource.DEPTH_ZERO);
//			for (int i = 0; i < markers.length; i++) {
//				if (markers[i].getAttributes().equals(attributes)) {
//					return true;
//				}
//			}
//			return false;
//		}
//	}
//
//	class ProjectSnapshot extends ResourceSnapshot {
//		ResourceSnapshot[] memberSnapshots;
//
//		ProjectSnapshot(IProject project) throws CoreException {
//			name = project.getName();
//			boolean open = project.isOpen();
//			if (!open) {
//				project.open(null);
//			}
//			IResource[] members = project.members();
//			memberSnapshots = new ResourceSnapshot[members.length];
//			for (int i = 0; i < members.length; i++) {
//				memberSnapshots[i] = snapshotFromResource(members[i]);
//			}
//			if (!open) {
//				project.close(null);
//			}
//
//		}
//
//		boolean isValid(IResource parent) throws CoreException {
//			IResource resource = getWorkspaceRoot().findMember(
//					parent.getFullPath().append(name));
//			if (resource == null || !(resource instanceof IProject)) {
//				return false;
//			}
//			IProject project = (IProject) resource;
//			// Must open it to validate the content
//			boolean open = project.isOpen();
//			if (!open) {
//				project.open(null);
//			}
//
//			for (int i = 0; i < memberSnapshots.length; i++) {
//				if (!fileNameExcludes.contains(memberSnapshots[i].name)) {
//					if (!memberSnapshots[i].isValid(resource)) {
//						return false;
//					}
//				}
//			}
//
//			if (!open) {
//				project.close(null);
//			}
//
//			return true;
//		}
//
//		boolean isValid() throws CoreException {
//			return isValid(getWorkspaceRoot());
//		}
//	}
//
//	abstract class ResourceSnapshot {
//		String name;
//
//		abstract boolean isValid(IResource parent) throws CoreException;
//
//		IWorkspaceRoot getWorkspaceRoot() {
//			return ResourcesPlugin.getWorkspace().getRoot();
//		}
//	}
//
//	/**
//	 * @param testName
//	 */
//	public WorkspaceOperationsTests(String name) {
//		super(name);
//	}
//
//	protected void doSetUp() throws Exception {
//		super.doSetUp();
//		// Suppress validation UI
//		AdvancedValidationUserApprover.AUTOMATED_MODE = true;
//		// Project
//		testProject = getWorkspace().getRoot().getProject(TEST_PROJECT_NAME);
//		testProject.create(getMonitor());
//		testProject.open(getMonitor());
//		assertTrue(testProject.exists());
//		// Project for move/copy target location
//		targetProject = getWorkspace().getRoot().getProject(
//				TEST_TARGET_PROJECT_NAME);
//		targetProject.create(getMonitor());
//		targetProject.open(getMonitor());
//		assertTrue(targetProject.exists());
//		// Folder in Project
//		testFolder = testProject.getFolder(TEST_FOLDER_NAME);
//		testFolder.create(true, true, getMonitor());
//		assertTrue(testFolder.exists());
//		// File in Project
//		testFileInProject = testProject.getFile(TEST_FILEINPROJECT_NAME);
//		testFileInProject.create(getContents(getRandomString()), true,
//				getMonitor());
//		assertTrue(testFileInProject.exists());
//		// Subfolder in top level folder
//		testSubFolder = testFolder.getFolder(TEST_SUBFOLDER_NAME);
//		testSubFolder.create(true, true, getMonitor());
//		assertTrue(testSubFolder.exists());
//		// Files in top level folder
//		emptyTestFile = testFolder.getFile(TEST_EMPTYFILE_NAME);
//		emptyTestFile.create(getContents(FILE_CONTENTS_EMPTY), true,
//				getMonitor());
//		testFileWithContent = testFolder.getFile(TEST_RANDOMFILE_NAME);
//		testFileWithContent.create(getContents(getRandomString()), true,
//				getMonitor());
//		// File in subfolder
//		testFileInSubFolder = testSubFolder.getFile(TEST_FILEINSUBFOLDER_NAME);
//		testFileInSubFolder.create(getContents(getRandomString()), true,
//				getMonitor());
//		assertTrue(testFileInProject.exists());
//
//		// Create links by first creating the backing content...
//		IFileStore folderStore = getTempStore();
//		IFileStore fileStore = getTempStore();
//		IPath folderLocation = URIUtil.toPath(folderStore.toURI());
//		IPath fileLocation = URIUtil.toPath(fileStore.toURI());
//		folderStore.mkdir(EFS.NONE, getMonitor());
//		fileStore.openOutputStream(EFS.NONE, getMonitor()).close();
//		// Then create the workspace objects
//		testLinkedFolder = testFolder.getFolder(TEST_LINKEDFOLDER_NAME);
//		testLinkedFolder.createLink(folderLocation, IResource.NONE,
//				getMonitor());
//		assertTrue(testLinkedFolder.exists());
//		testLinkedFile = testFolder.getFile(TEST_LINKEDFILE_NAME);
//		testLinkedFile.createLink(fileLocation, IResource.NONE, getMonitor());
//
//		history = PlatformUI.getWorkbench().getOperationSupport()
//				.getOperationHistory();
//		context = PlatformUI.getWorkbench().getOperationSupport()
//				.getUndoContext();
//
//	}
//
//	protected void doTearDown() throws Exception {
//		testProject = (IProject) getWorkspaceRoot().findMember(
//				TEST_PROJECT_NAME);
//		if (testProject != null) {
//			testProject.close(getMonitor());
//			testProject.delete(true, true, getMonitor());
//		}
//		targetProject = (IProject) getWorkspaceRoot().findMember(
//				TEST_TARGET_PROJECT_NAME);
//		if (targetProject != null) {
//			targetProject.close(getMonitor());
//			targetProject.delete(true, true, getMonitor());
//		}
//		IProject newProject = (IProject) getWorkspaceRoot().findMember(
//				TEST_NEWPROJECT_NAME);
//		if (newProject != null) {
//			newProject.close(getMonitor());
//			newProject.delete(true, true, getMonitor());
//		}
//		final IFileStore[] toDelete = (IFileStore[]) storesToDelete
//				.toArray(new IFileStore[storesToDelete.size()]);
//		storesToDelete.clear();
//		for (int i = 0; i < toDelete.length; i++) {
//			clear(toDelete[i]);
//		}
//		AdvancedValidationUserApprover.AUTOMATED_MODE = false;
//
//		testProject = null;
//		targetProject = null;
//		testFolder = null;
//		testSubFolder = null;
//		testLinkedFolder = null;
//		emptyTestFile = null;
//		testFileWithContent = null;
//		testLinkedFile = null;
//		testFileInSubFolder = null;
//		testFileInProject = null;
//
//		super.doTearDown();
//	}
//
//	private IWorkspace getWorkspace() {
//		return ResourcesPlugin.getWorkspace();
//	}
//
//	private IWorkspaceRoot getWorkspaceRoot() {
//		return ResourcesPlugin.getWorkspace().getRoot();
//	}
//
//	/*
//	 * reads file content and returns string
//	 */
//	private String readContent(IFile file) throws CoreException {
//		InputStream is = file.getContents();
//		String encoding = file.getCharset();
//		if (is == null)
//			return null;
//		BufferedReader reader = null;
//		try {
//			StringBuffer buffer = new StringBuffer();
//			char[] part = new char[2048];
//			int read = 0;
//			reader = new BufferedReader(new InputStreamReader(is, encoding));
//
//			while ((read = reader.read(part)) != -1)
//				buffer.append(part, 0, read);
//
//			return buffer.toString();
//
//		} catch (IOException ex) {
//		} finally {
//			if (reader != null) {
//				try {
//					reader.close();
//				} catch (IOException ex) {
//				}
//			}
//		}
//		return null;
//	}
//
//	private ResourceSnapshot snapshotFromResource(IResource resource)
//			throws CoreException {
//		if (resource instanceof IFile)
//			return new FileSnapshot((IFile) resource);
//		if (resource instanceof IFolder)
//			return new FolderSnapshot((IFolder) resource);
//		if (resource instanceof IProject)
//			return new ProjectSnapshot((IProject) resource);
//		fail("Unknown resource type");
//		// making compiler happy
//		return new FileSnapshot((IFile) resource);
//	}
//
//	private IProgressMonitor getMonitor() {
//		return null;
//	}
//
//	private String getRandomString() {
//		switch ((int) Math.round(Math.random() * 10)) {
//		case 0:
//			return "este e' o meu conteudo (portuguese)";
//		case 1:
//			return "ho ho ho";
//		case 2:
//			return "I'll be back";
//		case 3:
//			return "don't worry, be happy";
//		case 4:
//			return "there is no imagination for more sentences";
//		case 5:
//			return "customize yours";
//		case 6:
//			return "foo";
//		case 7:
//			return "bar";
//		case 8:
//			return "foobar";
//		case 9:
//			return "case 9";
//		default:
//			return "these are my contents";
//		}
//	}
//
//	/**
//	 * Returns a FileStore instance backed by storage in a temporary location.
//	 * The returned store will not exist, but will belong to an existing parent.
//	 * The tearDown method in this class will ensure the location is deleted
//	 * after the test is completed.
//	 */
//	private IFileStore getTempStore() {
//		IFileStore store = EFS.getLocalFileSystem().getStore(
//				FileSystemHelper.getRandomLocation(FileSystemHelper
//						.getTempDir()));
//		storesToDelete.add(store);
//		return store;
//	}
//
//	/**
//	 * Returns the URI for a unique, existent folder backed by storage in a
//	 * temporary location. The tearDown method in this class will ensure the
//	 * location is deleted after the test is completed.
//	 */
//	private URI getTempProjectDir() throws CoreException {
//		IFileStore store = getTempStore();
//		store.mkdir(EFS.NONE, getMonitor());
//		return store.toURI();
//	}
//
//	private void clear(IFileStore store) {
//		try {
//			store.delete(EFS.NONE, null);
//		} catch (CoreException e) {
//		}
//	}
//
//	private InputStream getContents(String text) {
//		return new ByteArrayInputStream(text.getBytes());
//	}
//
//	private Map getInitialMarkerAttributes() {
//		HashMap map = new HashMap();
//		map.putAll(initialAttributes);
//		return map;
//	}
//
//	private Map getUpdatedMarkerAttributes() {
//		HashMap map = new HashMap();
//		map.putAll(updatedAttributes);
//		return map;
//	}
//
//	private IProjectDescription getNewProjectDescription() {
//		return getWorkspace().newProjectDescription(TEST_NEWPROJECT_NAME);
//	}
//
//	private void execute(AbstractWorkspaceOperation operation)
//			throws ExecutionException {
//		operation.setQuietCompute(true);
//		assertTrue("Operation can be executed", operation.canExecute());
//		IStatus status = history.execute(operation, getMonitor(), null);
//		assertTrue("Execution should be OK status", status.isOK());
//	}
//
//	private void executeExpectFail(AbstractWorkspaceOperation operation)
//			throws ExecutionException {
//		operation.setQuietCompute(true);
//		IStatus status = history.execute(operation, getMonitor(), null);
//		assertFalse("Execution should not have OK status", status.isOK());
//	}
//
//	private void undo() throws ExecutionException {
//		assertTrue("Operation can be undone", history.canUndo(context));
//		IStatus status = history.undo(context, getMonitor(), null);
//		assertTrue("Undo should be OK status", status.isOK());
//	}
//
//	private void undoExpectFail(AbstractWorkspaceOperation operation)
//			throws ExecutionException {
//		operation.setQuietCompute(true);
//		IStatus status = history.undo(context, getMonitor(), null);
//		assertFalse("Undo should not have OK status", status.isOK());
//	}
//
//	private void redo() throws ExecutionException {
//		assertTrue("Operation can be redone", history.canRedo(context));
//		IStatus status = history.redo(context, getMonitor(), null);
//		assertTrue("Redo should be OK status", status.isOK());
//	}
//
//	private void validateCreatedMarkers(int expectedCount, IMarker[] markers,
//			Map[] expectedAttributes, String[] expectedTypes)
//			throws CoreException {
//
//		assertTrue(MessageFormat.format("{0} markers should have been created",
//				new Object[] { new Integer(expectedCount) }),
//				markers.length == expectedCount);
//
//		for (int i = 0; i < markers.length; i++) {
//			IMarker createdMarker = markers[i];
//			assertTrue("Marker should exist", createdMarker.exists());
//			assertTrue("Marker should have expected attributes", createdMarker
//					.getAttributes().equals(expectedAttributes[i]));
//			assertTrue("Marker should have expected type", createdMarker
//					.getType().equals(expectedTypes[i]));
//		}
//	}
//
//	public void testCreateSingleMarkerUndoRedo() throws ExecutionException,
//			CoreException {
//		String[] types = new String[] { IMarker.BOOKMARK };
//		Map[] attrs = new Map[] { getInitialMarkerAttributes() };
//		CreateMarkersOperation op = new CreateMarkersOperation(
//				IMarker.BOOKMARK, getInitialMarkerAttributes(), emptyTestFile,
//				"Create Single Marker Test");
//		execute(op);
//		IMarker[] markers = op.getMarkers();
//		validateCreatedMarkers(1, markers, attrs, types);
//		undo();
//		assertFalse("Marker should no longer exist", markers[0].exists());
//		redo();
//		markers = op.getMarkers();
//		validateCreatedMarkers(1, markers, attrs, types);
//	}
//
//	public void testCreateMultipleMarkersSingleTypeUndoRedo()
//			throws ExecutionException, CoreException {
//		String[] types = new String[] { CUSTOM_TYPE, CUSTOM_TYPE, CUSTOM_TYPE };
//		Map[] attrs = new Map[] { getInitialMarkerAttributes(),
//				getUpdatedMarkerAttributes(), getInitialMarkerAttributes() };
//
//		CreateMarkersOperation op = new CreateMarkersOperation(CUSTOM_TYPE,
//				attrs, new IFile[] { emptyTestFile, testFileWithContent,
//						testLinkedFile },
//				"Create Multiple Markers Single Type Test");
//		execute(op);
//		IMarker[] markers = op.getMarkers();
//		validateCreatedMarkers(3, markers, attrs, types);
//		undo();
//		for (int i = 0; i < markers.length; i++) {
//			IMarker createdMarker = markers[i];
//			assertFalse("Marker should no longer exist", createdMarker.exists());
//		}
//		redo();
//		markers = op.getMarkers();
//		validateCreatedMarkers(3, markers, attrs, types);
//	}
//
//	public void testCreateMultipleMarkerTypesUndoRedo()
//			throws ExecutionException, CoreException {
//		String[] types = new String[] { IMarker.BOOKMARK, IMarker.TASK,
//				CUSTOM_TYPE };
//		Map[] attrs = new Map[] { getInitialMarkerAttributes(),
//				getUpdatedMarkerAttributes(), getInitialMarkerAttributes() };
//
//		CreateMarkersOperation op = new CreateMarkersOperation(types, attrs,
//				new IFile[] { emptyTestFile, testFileWithContent,
//						testLinkedFile }, "Create Multiple Marker Types Test");
//		execute(op);
//		IMarker[] markers = op.getMarkers();
//		validateCreatedMarkers(3, markers, attrs, types);
//		undo();
//		for (int i = 0; i < markers.length; i++) {
//			IMarker createdMarker = markers[i];
//			assertFalse("Marker should no longer exist", createdMarker.exists());
//		}
//		redo();
//		markers = op.getMarkers();
//		validateCreatedMarkers(3, markers, attrs, types);
//	}
//
//	public void testUpdateSingleMarkerUndoRedo() throws ExecutionException,
//			CoreException {
//		CreateMarkersOperation op = new CreateMarkersOperation(
//				IMarker.BOOKMARK, getInitialMarkerAttributes(),
//				testFileWithContent, "Create Marker Test");
//		execute(op);
//		UpdateMarkersOperation updateOp = new UpdateMarkersOperation(op
//				.getMarkers()[0], getUpdatedMarkerAttributes(),
//				"Update Single Marker", false);
//		execute(updateOp);
//		validateCreatedMarkers(1, updateOp.getMarkers(),
//				new Map[] { getUpdatedMarkerAttributes() },
//				new String[] { IMarker.BOOKMARK });
//		undo();
//		validateCreatedMarkers(1, updateOp.getMarkers(),
//				new Map[] { getInitialMarkerAttributes() },
//				new String[] { IMarker.BOOKMARK });
//		redo();
//		validateCreatedMarkers(1, updateOp.getMarkers(),
//				new Map[] { getUpdatedMarkerAttributes() },
//				new String[] { IMarker.BOOKMARK });
//
//	}
//
//	public void testUpdateMultipleMarkerUndoRedo() throws ExecutionException,
//			CoreException {
//		String[] types = new String[] { IMarker.BOOKMARK, IMarker.TASK,
//				CUSTOM_TYPE };
//		Map[] attrs = new Map[] { getInitialMarkerAttributes(),
//				getInitialMarkerAttributes(), getInitialMarkerAttributes() };
//		CreateMarkersOperation op = new CreateMarkersOperation(types, attrs,
//				new IFile[] { emptyTestFile, testFileWithContent,
//						testLinkedFile },
//				"Create Multiple Markers Same Type Test");
//		execute(op);
//		UpdateMarkersOperation updateOp = new UpdateMarkersOperation(op
//				.getMarkers(), getUpdatedMarkerAttributes(),
//				"Update Multiple Markers", false);
//		execute(updateOp);
//		validateCreatedMarkers(3, updateOp.getMarkers(), new Map[] {
//				getUpdatedMarkerAttributes(), getUpdatedMarkerAttributes(),
//				getUpdatedMarkerAttributes() }, types);
//		undo();
//		validateCreatedMarkers(3, updateOp.getMarkers(), attrs, types);
//		redo();
//		validateCreatedMarkers(3, updateOp.getMarkers(), new Map[] {
//				getUpdatedMarkerAttributes(), getUpdatedMarkerAttributes(),
//				getUpdatedMarkerAttributes() }, types);
//
//	}
//
//	public void testUpdateAndMergeSingleMarkerUndoRedo()
//			throws ExecutionException, CoreException {
//		CreateMarkersOperation op = new CreateMarkersOperation(
//				IMarker.BOOKMARK, getInitialMarkerAttributes(), testLinkedFile,
//				"Create Marker Test");
//		execute(op);
//		UpdateMarkersOperation updateOp = new UpdateMarkersOperation(op
//				.getMarkers()[0], getUpdatedMarkerAttributes(),
//				"Update And Merge Single Marker", true);
//		execute(updateOp);
//		validateCreatedMarkers(1, updateOp.getMarkers(),
//				new Map[] { mergedUpdatedAttributes },
//				new String[] { IMarker.BOOKMARK });
//		undo();
//		validateCreatedMarkers(1, updateOp.getMarkers(),
//				new Map[] { getInitialMarkerAttributes() },
//				new String[] { IMarker.BOOKMARK });
//		redo();
//		validateCreatedMarkers(1, updateOp.getMarkers(),
//				new Map[] { mergedUpdatedAttributes },
//				new String[] { IMarker.BOOKMARK });
//
//	}
//
//	public void testUpdateAndMergeMultipleMarkerUndoRedo()
//			throws ExecutionException, CoreException {
//		String[] types = new String[] { IMarker.BOOKMARK, IMarker.TASK,
//				CUSTOM_TYPE };
//		Map[] attrs = new Map[] { getInitialMarkerAttributes(),
//				getInitialMarkerAttributes(), getInitialMarkerAttributes() };
//		CreateMarkersOperation op = new CreateMarkersOperation(types, attrs,
//				new IFile[] { emptyTestFile, testFileWithContent,
//						testLinkedFile },
//				"Create Multiple Markers Same Type Test");
//		execute(op);
//		UpdateMarkersOperation updateOp = new UpdateMarkersOperation(op
//				.getMarkers(), getUpdatedMarkerAttributes(),
//				"Update and Merge Multiple Markers", true);
//		execute(updateOp);
//		validateCreatedMarkers(3, updateOp.getMarkers(), new Map[] {
//				mergedUpdatedAttributes, mergedUpdatedAttributes,
//				mergedUpdatedAttributes }, types);
//		undo();
//		validateCreatedMarkers(3, updateOp.getMarkers(), attrs, types);
//		redo();
//		validateCreatedMarkers(3, updateOp.getMarkers(), new Map[] {
//				mergedUpdatedAttributes, mergedUpdatedAttributes,
//				mergedUpdatedAttributes }, types);
//	}
//
//	public void testDeleteMarkersUndoRedo() throws ExecutionException,
//			CoreException {
//		String[] types = new String[] { IMarker.BOOKMARK, IMarker.TASK,
//				CUSTOM_TYPE };
//		Map[] attrs = new Map[] { getInitialMarkerAttributes(),
//				getUpdatedMarkerAttributes(), getInitialMarkerAttributes() };
//		CreateMarkersOperation op = new CreateMarkersOperation(types, attrs,
//				new IFile[] { emptyTestFile, testFileWithContent,
//						testLinkedFile },
//				"Create Multiple Markers Same Type Test");
//		execute(op);
//		IMarker[] markers = op.getMarkers();
//		DeleteMarkersOperation deleteOp = new DeleteMarkersOperation(markers,
//				"Delete Markers Test");
//		execute(deleteOp);
//		for (int i = 0; i < markers.length; i++) {
//			IMarker createdMarker = markers[i];
//			assertFalse("Marker should no longer exist", createdMarker.exists());
//		}
//		undo();
//		markers = deleteOp.getMarkers();
//		validateCreatedMarkers(3, markers, attrs, types);
//		redo();
//		for (int i = 0; i < markers.length; i++) {
//			IMarker createdMarker = markers[i];
//			assertFalse("Marker should no longer exist", createdMarker.exists());
//		}
//	}
//
//	/*
//	 * Test that the undo is invalid because one of the markers was deleted.
//	 */
//	public void testCreateMarkerUndoInvalid() throws ExecutionException,
//			CoreException {
//		String[] types = new String[] { IMarker.BOOKMARK, IMarker.TASK,
//				CUSTOM_TYPE };
//		Map[] attrs = new Map[] { getInitialMarkerAttributes(),
//				getUpdatedMarkerAttributes(), getInitialMarkerAttributes() };
//		CreateMarkersOperation op = new CreateMarkersOperation(types, attrs,
//				new IFile[] { emptyTestFile, testFileWithContent,
//						testLinkedFile },
//				"Create Multiple Markers Same Type Test");
//		execute(op);
//		IMarker[] markers = op.getMarkers();
//		markers[1].delete();
//		// Must compute status first because we don't perform expensive
//		// validations in canUndo(). However we should remember the validity
//		// once we've computed the status.
//		op.computeUndoableStatus(null);
//		assertFalse("Undo should be invalid, marker no longer exists", op
//				.canUndo());
//	}
//
//	/*
//	 * Test that the undo is invalid because one of the resources was deleted.
//	 */
//	public void testCreateMarkerUndoInvalid2() throws ExecutionException,
//			CoreException {
//		String[] types = new String[] { IMarker.BOOKMARK, IMarker.TASK,
//				CUSTOM_TYPE };
//		Map[] attrs = new Map[] { getInitialMarkerAttributes(),
//				getUpdatedMarkerAttributes(), getInitialMarkerAttributes() };
//		CreateMarkersOperation op = new CreateMarkersOperation(types, attrs,
//				new IFile[] { emptyTestFile, testFileWithContent,
//						testLinkedFile },
//				"Create Multiple Markers Same Type Test");
//		execute(op);
//		emptyTestFile.delete(true, getMonitor());
//		// Must compute status first because we don't perform expensive
//		// validations in canUndo(). However we should remember the validity
//		// once we've computed the status.
//		op.computeUndoableStatus(null);
//		assertFalse("Undo should be invalid, resource no longer exists", op
//				.canUndo());
//	}
//
//	public void testUpdateMarkersInvalid() throws ExecutionException,
//			CoreException {
//		String[] types = new String[] { IMarker.BOOKMARK, IMarker.TASK,
//				CUSTOM_TYPE };
//		Map[] attrs = new Map[] { getInitialMarkerAttributes(),
//				getInitialMarkerAttributes(), getInitialMarkerAttributes() };
//		CreateMarkersOperation op = new CreateMarkersOperation(types, attrs,
//				new IFile[] { emptyTestFile, testFileWithContent,
//						testLinkedFile },
//				"Create Multiple Markers Same Type Test");
//		execute(op);
//		UpdateMarkersOperation updateOp = new UpdateMarkersOperation(op
//				.getMarkers(), getUpdatedMarkerAttributes(),
//				"Update and Merge Multiple Markers", true);
//		execute(updateOp);
//		IMarker[] markers = updateOp.getMarkers();
//		markers[0].delete();
//		// Must compute status first because we don't perform expensive
//		// validations in canUndo(). However we should remember the validity
//		// once we've computed the status.
//		updateOp.computeUndoableStatus(null);
//
//		assertFalse("Undo should be invalid, marker no longer exists", updateOp
//				.canUndo());
//	}
//
//	public void testUpdateMarkersInvalid2() throws ExecutionException,
//			CoreException {
//		String[] types = new String[] { IMarker.BOOKMARK, IMarker.TASK,
//				CUSTOM_TYPE };
//		Map[] attrs = new Map[] { getInitialMarkerAttributes(),
//				getInitialMarkerAttributes(), getInitialMarkerAttributes() };
//		CreateMarkersOperation op = new CreateMarkersOperation(types, attrs,
//				new IFile[] { emptyTestFile, testFileWithContent,
//						testLinkedFile },
//				"Create Multiple Markers Same Type Test");
//		execute(op);
//		UpdateMarkersOperation updateOp = new UpdateMarkersOperation(op
//				.getMarkers(), getUpdatedMarkerAttributes(),
//				"Update and Merge Multiple Markers", true);
//		execute(updateOp);
//		testFileWithContent.delete(true, getMonitor());
//		// Must compute status first because we don't perform expensive
//		// validations in canUndo(). However we should remember the validity
//		// once we've computed the status.
//		updateOp.computeUndoableStatus(null);
//
//		assertFalse("Undo should be invalid, marker no longer exists", updateOp
//				.canUndo());
//	}
//
//	public void testProjectCreateUndoRedo() throws ExecutionException,
//			CoreException {
//		CreateProjectOperation op = new CreateProjectOperation(
//				getNewProjectDescription(), "testProjectCreate");
//		execute(op);
//		IProject project = getWorkspaceRoot().getProject(TEST_NEWPROJECT_NAME);
//		assertTrue("Project creation failed", project.exists());
//		ProjectSnapshot snap = new ProjectSnapshot(project);
//		undo();
//		assertFalse("Project deletion failed", project.exists());
//		redo();
//		assertTrue("Project recreation failed", project.exists());
//		assertTrue("Project not restored properly", snap.isValid());
//	}
//
//	public void testProjectMoveUndoRedo() throws ExecutionException,
//			CoreException {
//		URI projectTargetLocation = URIUtil.toURI(URIUtil.toPath(
//				getTempProjectDir()).append(TEST_PROJECT_NAME));
//		MoveProjectOperation op = new MoveProjectOperation(testProject,
//				projectTargetLocation, "testProjectMove");
//		ProjectSnapshot snap = new ProjectSnapshot(testProject);
//		execute(op);
//		assertNotNull("Project move failed", testProject.getDescription()
//				.getLocationURI());
//		assertTrue("Project contents were altered", snap.isValid());
//		undo();
//		assertNull("Project move undo failed", testProject.getDescription()
//				.getLocationURI());
//		assertTrue("Project contents were altered", snap.isValid());
//		redo();
//		assertEquals("Project move redo failed", testProject.getDescription()
//				.getLocationURI(), projectTargetLocation);
//		assertTrue("Project contents were altered", snap.isValid());
//	}
//
//	public void testProjectMoveInvalidLocationUndoRedo()
//			throws ExecutionException {
//		// invalid target - already used by another project
//		MoveProjectOperation op = new MoveProjectOperation(testProject,
//				targetProject.getLocationURI(),
//				"testProjectMoveInvalidLocation");
//		executeExpectFail(op);
//	}
//
//	public void testProjectCopyUndoRedo() throws ExecutionException,
//			CoreException {
//		CopyProjectOperation op = new CopyProjectOperation(testProject,
//				TEST_NEWPROJECT_NAME, null, "testProjectCopy");
//		ProjectSnapshot snap = new ProjectSnapshot(testProject);
//		execute(op);
//		IProject copiedProject = getWorkspaceRoot().getProject(
//				TEST_NEWPROJECT_NAME);
//		assertTrue("Project copy failed", copiedProject.exists());
//		assertTrue("Source project was altered", snap.isValid());
//		snap.name = TEST_NEWPROJECT_NAME;
//		assertTrue("Project copy does not match", snap.isValid());
//		undo();
//		assertFalse("Copy undo failed", copiedProject.exists());
//		redo();
//		assertTrue("Project not restored properly on redo", snap.isValid());
//		snap.name = TEST_PROJECT_NAME;
//		assertTrue("Source project was altered", snap.isValid());
//	}
//
//	public void testProjectClosedCopyUndoRedo() throws ExecutionException,
//			CoreException {
//		testProject.close(getMonitor());
//		testProjectCopyUndoRedo();
//	}
//
//	public void testProjectCopyAndChangeLocationUndoRedo()
//			throws ExecutionException, CoreException {
//		URI projectTargetLocation = URIUtil.toURI(URIUtil.toPath(
//				getTempProjectDir()).append(TEST_PROJECT_NAME));
//		CopyProjectOperation op = new CopyProjectOperation(testProject,
//				TEST_NEWPROJECT_NAME, projectTargetLocation,
//				"testProjectCopyToNewLocation");
//		ProjectSnapshot snap = new ProjectSnapshot(testProject);
//		execute(op);
//		IProject copiedProject = getWorkspaceRoot().getProject(
//				TEST_NEWPROJECT_NAME);
//		assertTrue("Project copy failed", copiedProject.exists());
//		assertEquals("Project location copy failed", copiedProject
//				.getDescription().getLocationURI(), projectTargetLocation);
//		assertTrue("Source project was altered", snap.isValid());
//		snap.name = TEST_NEWPROJECT_NAME;
//		assertTrue("Project copy does not match", snap.isValid());
//		undo();
//		assertFalse("Copy undo failed", copiedProject.exists());
//		redo();
//		assertTrue("Project not restored properly on redo", snap.isValid());
//		assertEquals("Project location not restored properly", copiedProject
//				.getDescription().getLocationURI(), projectTargetLocation);
//		snap.name = TEST_PROJECT_NAME;
//		assertTrue("Source project was altered", snap.isValid());
//	}
//
//	public void testProjectClosedCopyAndChangeLocationUndoRedo()
//			throws ExecutionException, CoreException {
//		testProject.close(getMonitor());
//		testProjectCopyAndChangeLocationUndoRedo();
//	}
//
//	public void testProjectCopyAndChangeToInvalidLocationUndoRedo()
//			throws ExecutionException {
//		// invalid target - already used by another project
//		CopyProjectOperation op = new CopyProjectOperation(testProject,
//				TEST_NEWPROJECT_NAME, targetProject.getLocationURI(),
//				"testProjectCopyInvalidLocation");
//		executeExpectFail(op);
//	}
//
//	public void testProjectRenameUndoRedo() throws ExecutionException,
//			CoreException {
//		MoveResourcesOperation op = new MoveResourcesOperation(testProject,
//				new Path(TEST_NEWPROJECT_NAME), "testProjectRename");
//		ProjectSnapshot snap = new ProjectSnapshot(testProject);
//		execute(op);
//		IProject renamedProject = getWorkspaceRoot().getProject(
//				TEST_NEWPROJECT_NAME);
//		assertTrue("Project rename failed", renamedProject.exists());
//		snap.name = TEST_NEWPROJECT_NAME;
//		assertTrue("Project content was altered on rename", snap.isValid());
//		undo();
//		snap.name = TEST_PROJECT_NAME;
//		assertTrue("Project content was altered on undo rename", snap.isValid());
//		assertFalse("Undo rename failed", renamedProject.exists());
//		redo();
//		snap.name = TEST_NEWPROJECT_NAME;
//		assertTrue("Project content was altered on redo rename", snap.isValid());
//	}
//
//	public void testProjectDeleteUndoRedo() throws ExecutionException {
//		DeleteResourcesOperation op = new DeleteResourcesOperation(
//				new IResource[] { testProject }, "testProjectDelete", false);
//		execute(op);
//		assertFalse("Project delete failed", testProject.exists());
//		undo();
//		assertTrue("Project recreation failed", testProject.exists());
//		// Ideally we could run this test everytime, but it fails intermittently
//		// because opening the recreated project occurs in the background, and
//		// the creation of the workspace representation for the disk contents
//		// may not have happened yet. This test always passes under debug where
//		// timing can be controlled.
//		// ***********
//		// assertTrue("Project content was altered on undo", snap.isValid());
//		// ************
//		redo();
//		assertFalse("Redo delete failed", testProject.exists());
//		// We undo again so that the project will exist during teardown and
//		// get cleaned up. Otherwise some content is left on disk.
//		undo();
//	}
//
//	public void testProjectClosedDeleteUndoRedo() throws ExecutionException,
//			CoreException {
//		testProject.close(getMonitor());
//		testProjectDeleteUndoRedo();
//	}
//
//	public void testProjectDeleteWithContentUndoRedo()
//			throws ExecutionException {
//		DeleteResourcesOperation op = new DeleteResourcesOperation(
//				new IResource[] { testProject }, "testProjectDelete", true);
//		// we don't snapshot since content will be deleted
//		execute(op);
//		assertFalse("Project delete failed", testProject.exists());
//		undo();
//		assertTrue("Project was recreated", testProject.exists());
//		redo();
//		assertFalse("Redo delete failed", testProject.exists());
//	}
//
//	public void testProjectClosedDeleteWithContentUndoRedo()
//			throws ExecutionException, CoreException {
//		testProject.close(getMonitor());
//		testProjectDeleteWithContentUndoRedo();
//	}
//
//	public void testFolderCreateLeafUndoRedo() throws ExecutionException {
//		IFolder folder = getWorkspaceRoot().getFolder(
//				testProject.getFullPath().append(TEST_NEWFOLDER_NAME));
//		CreateFolderOperation op = new CreateFolderOperation(folder, null,
//				"testFolderCreateLeaf");
//		assertFalse("Folder should not exist before test is run", folder
//				.exists());
//		execute(op);
//		assertTrue("Folder creation failed", folder.exists());
//		undo();
//		assertFalse("Folder deletion failed", folder.exists());
//		redo();
//		assertTrue("Folder recreation failed", folder.exists());
//	}
//
//	public void testFolderCreateNestedInProjectUndoRedo()
//			throws ExecutionException {
//		// uses a nested path to force creation of nonexistent parents
//		IFolder folder = getWorkspaceRoot().getFolder(
//				testProject.getFullPath().append(TEST_NEWNESTEDFOLDER_NAME));
//		CreateFolderOperation op = new CreateFolderOperation(folder, null,
//				"testFolderCreateNested");
//		assertFalse("Folder should not exist before test is run", folder
//				.exists());
//		execute(op);
//		assertTrue("Folder creation failed", folder.exists());
//		undo();
//		assertFalse("Folder deletion failed", folder.exists());
//		// Ensure all created parents are gone, too
//		IPath path = new Path(TEST_NEWNESTEDFOLDER_NAME);
//		path.removeLastSegments(path.segmentCount() - 1);
//		IFolder parent = getWorkspaceRoot().getFolder(
//				testProject.getFullPath().append(path));
//		assertFalse("Deletion of created parents failed", parent.exists());
//
//		redo();
//		assertTrue("Folder recreation failed", folder.exists());
//	}
//
//	public void testFolderCreateNestedInFolderUndoRedo()
//			throws ExecutionException {
//		// Uses a nested path to force creation of nonexistent parents.
//		// Parent is a folder, not a project.
//		IFolder folder = getWorkspaceRoot().getFolder(
//				testFolder.getFullPath().append(TEST_NEWNESTEDFOLDER_NAME));
//		CreateFolderOperation op = new CreateFolderOperation(folder, null,
//				"testFolderCreateNestedInFolder");
//		assertFalse("Folder should not exist before test is run", folder
//				.exists());
//		execute(op);
//		assertTrue("Folder creation failed", folder.exists());
//
//		undo();
//		assertFalse("Folder deletion failed", folder.exists());
//		// Ensure all created parents are gone, too
//		IPath path = new Path(TEST_NEWNESTEDFOLDER_NAME);
//		path.removeLastSegments(path.segmentCount() - 1);
//		IFolder parent = getWorkspaceRoot().getFolder(
//				testFolder.getFullPath().append(path));
//		assertFalse("Deletion of created parents failed", parent.exists());
//
//		redo();
//		assertTrue("Folder recreation failed", folder.exists());
//	}
//
//	public void testFolderCreateLinkedUndoRedo() throws ExecutionException {
//		IFolder folder = getWorkspaceRoot().getFolder(
//				testProject.getFullPath().append(TEST_NEWFOLDER_NAME));
//		CreateFolderOperation op = new CreateFolderOperation(folder,
//				testSubFolder.getLocationURI(), "testFolderCreateLink");
//		assertFalse("Folder should not exist before test is run", folder
//				.exists());
//		execute(op);
//		assertTrue("Folder creation failed", folder.exists());
//		assertTrue("Folder was not created as a link", folder.isLinked());
//		undo();
//		assertFalse("Folder deletion failed", folder.exists());
//		redo();
//		assertTrue("Folder recreation failed", folder.exists());
//		assertTrue("Folder was not recreated as a link", folder.isLinked());
//	}
//
//	public void testFolderCreateLinkedNestedUndoRedo()
//			throws ExecutionException {
//		// Use nested name with uncreated parents
//		IFolder folder = getWorkspaceRoot().getFolder(
//				testProject.getFullPath().append(TEST_NEWNESTEDFOLDER_NAME));
//		CreateFolderOperation op = new CreateFolderOperation(folder,
//				testSubFolder.getLocationURI(), "testFolderCreateNestedLink");
//		assertFalse("Folder should not exist before test is run", folder
//				.exists());
//		execute(op);
//		assertTrue("Folder creation failed", folder.exists());
//		assertTrue("Folder was not created as a link", folder.isLinked());
//		undo();
//		assertFalse("Folder deletion failed", folder.exists());
//		// Ensure all created parents are gone, too
//		IPath path = new Path(TEST_NEWNESTEDFOLDER_NAME);
//		path.removeLastSegments(path.segmentCount() - 1);
//		IFolder parent = getWorkspaceRoot().getFolder(
//				testProject.getFullPath().append(path));
//		assertFalse("Parents should have been removed", parent.exists());
//		// Redo
//		redo();
//		assertTrue("Folder recreation failed", folder.exists());
//		assertTrue("Folder was not recreated as a link", folder.isLinked());
//	}
//
//	public void testFolderMoveUndoRedo() throws ExecutionException,
//			CoreException {
//		IPath targetPath = targetProject.getFullPath().append(
//				testFolder.getName());
//		MoveResourcesOperation op = new MoveResourcesOperation(testFolder,
//				targetPath, "testFolderMove");
//		FolderSnapshot snap = new FolderSnapshot(testFolder);
//		execute(op);
//		IFolder movedFolder = getWorkspaceRoot().getFolder(targetPath);
//		assertTrue("Folder move failed", movedFolder.exists());
//		assertTrue("Folder content was altered", snap.isValid(targetProject));
//
//		undo();
//		movedFolder = getWorkspaceRoot().getFolder(targetPath);
//		assertFalse("Move undo failed", movedFolder.exists());
//		assertTrue("Folder content was altered on undo", snap
//				.isValid(testProject));
//
//		redo();
//		movedFolder = getWorkspaceRoot().getFolder(targetPath);
//		assertTrue("Folder move failed", movedFolder.exists());
//		assertTrue("Folder content was altered", snap.isValid(targetProject));
//	}
//
//	public void testRedundantSubFolderMoveUndoRedo() throws ExecutionException,
//			CoreException {
//		IPath targetPath = targetProject.getFullPath();
//		IPath targetPathWithName = targetPath.append(testFolder.getName());
//		MoveResourcesOperation op = new MoveResourcesOperation(new IResource[] {
//				testFolder, testSubFolder }, targetPath,
//				"testRedundantSubFolderMove");
//		FolderSnapshot snap = new FolderSnapshot(testFolder);
//		execute(op);
//		IFolder movedFolder = getWorkspaceRoot().getFolder(targetPathWithName);
//		assertTrue("Folder move failed", movedFolder.exists());
//		assertTrue("Folder content was altered", snap.isValid(targetProject));
//
//		undo();
//		movedFolder = getWorkspaceRoot().getFolder(targetPathWithName);
//		assertFalse("Move undo failed", movedFolder.exists());
//		assertTrue("Folder content was altered on undo", snap
//				.isValid(testProject));
//
//		redo();
//		movedFolder = getWorkspaceRoot().getFolder(targetPathWithName);
//		assertTrue("Folder move failed", movedFolder.exists());
//		assertTrue("Folder content was altered", snap.isValid(targetProject));
//	}
//
//	public void testRedundantFolderFileMoveUndoRedo()
//			throws ExecutionException, CoreException {
//		IPath targetPath = targetProject.getFullPath();
//		IPath targetPathWithName = targetPath.append(testFolder.getName());
//		MoveResourcesOperation op = new MoveResourcesOperation(new IResource[] {
//				testFolder, testFileWithContent }, targetPath,
//				"testRedundantFolderFileMove");
//		FolderSnapshot snap = new FolderSnapshot(testFolder);
//		execute(op);
//		IFolder movedFolder = getWorkspaceRoot().getFolder(targetPathWithName);
//		assertTrue("Folder move failed", movedFolder.exists());
//		assertTrue("Folder content was altered", snap.isValid(targetProject));
//
//		undo();
//		movedFolder = getWorkspaceRoot().getFolder(targetPathWithName);
//		assertFalse("Move undo failed", movedFolder.exists());
//		assertTrue("Folder content was altered on undo", snap
//				.isValid(testProject));
//
//		redo();
//		movedFolder = getWorkspaceRoot().getFolder(targetPathWithName);
//		assertTrue("Folder move failed", movedFolder.exists());
//		assertTrue("Folder content was altered", snap.isValid(targetProject));
//	}
//
//	public void testFolderCopyUndoRedo() throws ExecutionException,
//			CoreException {
//		// copying with same name to a new project
//		CopyResourcesOperation op = new CopyResourcesOperation(
//				new IResource[] { testFolder }, targetProject.getFullPath(),
//				"testFolderCopy");
//		FolderSnapshot snap = new FolderSnapshot(testFolder);
//		execute(op);
//		IFolder copiedFolder = targetProject.getFolder(testFolder.getName());
//		assertTrue("Folder copy failed", copiedFolder.exists());
//		assertTrue("Source folder was altered", snap.isValid(testProject));
//		assertTrue("Folder copy does not match", snap.isValid(targetProject));
//
//		undo();
//		assertFalse("Copy undo failed", copiedFolder.exists());
//
//		redo();
//		assertTrue("Folder not restored properly on redo", snap
//				.isValid(targetProject));
//		assertTrue("Source folder was altered", snap.isValid(testProject));
//	}
//
//	public void testFolderCopyLinkUndoRedo() throws ExecutionException,
//			CoreException {
//		// copying with same name to a new project
//		CopyResourcesOperation op = new CopyResourcesOperation(
//				new IResource[] { testLinkedFolder }, targetProject
//						.getFullPath(), "testLinkedFolderCopy");
//		FolderSnapshot snap = new FolderSnapshot(testLinkedFolder);
//		execute(op);
//		IFolder copiedFolder = targetProject.getFolder(testLinkedFolder
//				.getName());
//		assertTrue("Folder copy failed", copiedFolder.exists());
//		assertTrue("Source folder was altered", snap.isValid(testFolder));
//		assertTrue("Folder copy does not match", snap.isValid(targetProject));
//
//		undo();
//		assertFalse("Copy undo failed", copiedFolder.exists());
//
//		redo();
//		assertTrue("Folder not restored properly on redo", snap
//				.isValid(targetProject));
//		assertTrue("Source folder was altered", snap.isValid(testFolder));
//	}
//
//	public void testFolderCopyRenameUndoRedo() throws ExecutionException,
//			CoreException {
//		// copying with a different name to the same project
//		CopyResourcesOperation op = new CopyResourcesOperation(testFolder,
//				testProject.getFullPath().append(TEST_NEWFOLDER_NAME),
//				"testFolderCopyRename");
//		FolderSnapshot snap = new FolderSnapshot(testFolder);
//		execute(op);
//
//		IFolder copiedFolder = testProject.getFolder(TEST_NEWFOLDER_NAME);
//		assertTrue("Folder copy failed", copiedFolder.exists());
//		assertTrue("Source folder was altered", snap.isValid(testProject));
//		snap.name = TEST_NEWFOLDER_NAME;
//		assertTrue("Folder copy does not match", snap.isValid(testProject));
//
//		undo();
//		assertFalse("Copy undo failed", copiedFolder.exists());
//
//		redo();
//		assertTrue("Folder not restored properly on redo", snap
//				.isValid(testProject));
//		snap.name = TEST_FOLDER_NAME;
//		assertTrue("Source folder was altered", snap.isValid(testProject));
//
//	}
//
//	public void testFolderRenameUndoRedo() throws ExecutionException,
//			CoreException {
//		MoveResourcesOperation op = new MoveResourcesOperation(testFolder,
//				testProject.getFullPath().append(TEST_NEWFOLDER_NAME),
//				"testFolderRename");
//		FolderSnapshot snap = new FolderSnapshot(testFolder);
//		execute(op);
//		IFolder renamedFolder = testProject.getFolder(TEST_NEWFOLDER_NAME);
//		assertTrue("Project rename failed", renamedFolder.exists());
//		snap.name = TEST_NEWFOLDER_NAME;
//		assertTrue("Folder content was altered on rename", snap
//				.isValid(testProject));
//
//		undo();
//		snap.name = TEST_FOLDER_NAME;
//		assertTrue("Folder content was altered on undo rename", snap
//				.isValid(testProject));
//		assertFalse("Undo rename failed", renamedFolder.exists());
//
//		redo();
//		snap.name = TEST_NEWFOLDER_NAME;
//		assertTrue("Folder content was altered on redo rename", snap
//				.isValid(testProject));
//	}
//
//	public void testFolderDeleteUndoRedo() throws ExecutionException,
//			CoreException {
//		DeleteResourcesOperation op = new DeleteResourcesOperation(
//				new IResource[] { testSubFolder }, "testFolderDelete", false);
//		FolderSnapshot snap = new FolderSnapshot(testSubFolder);
//		execute(op);
//		assertFalse("Folder delete failed", testSubFolder.exists());
//		undo();
//		assertTrue("Folder recreation failed", testSubFolder.exists());
//		assertTrue("Folder content was altered on undo", snap
//				.isValid(testSubFolder.getParent()));
//		redo();
//		assertFalse("Redo delete failed", testSubFolder.exists());
//	}
//
//	public void testNestedRedundantFolderDeleteUndoRedo()
//			throws ExecutionException, CoreException {
//		DeleteResourcesOperation op = new DeleteResourcesOperation(
//				new IResource[] { testFolder, testSubFolder },
//				"testNestedRedundantFolderDelete", false);
//		FolderSnapshot snap = new FolderSnapshot(testFolder);
//		execute(op);
//		assertFalse("Folder delete failed", testFolder.exists());
//		undo();
//		assertTrue("Folder recreation failed", testFolder.exists());
//		assertTrue("SubFolder recreation failed", testSubFolder.exists());
//		assertTrue("Folder content was altered on undo", snap
//				.isValid(testFolder.getParent()));
//		redo();
//		assertFalse("Redo delete failed", testFolder.exists());
//	}
//
//	public void testNestedRedundantFileDeleteUndoRedo()
//			throws ExecutionException, CoreException {
//		DeleteResourcesOperation op = new DeleteResourcesOperation(
//				new IResource[] { testFolder, testFileWithContent },
//				"testNestedRedundantFileDelete", false);
//		FolderSnapshot snap = new FolderSnapshot(testFolder);
//		execute(op);
//		assertFalse("Folder delete failed", testFolder.exists());
//		undo();
//		assertTrue("Folder recreation failed", testFolder.exists());
//		assertTrue("SubFolder recreation failed", testSubFolder.exists());
//		assertTrue("File recreation failed", testFileWithContent.exists());
//		assertTrue("Folder content was altered on undo", snap
//				.isValid(testFolder.getParent()));
//		redo();
//		assertFalse("Redo delete failed", testFolder.exists());
//	}
//
//	public void testFolderDeleteLinkedUndoRedo() throws ExecutionException,
//			CoreException {
//		DeleteResourcesOperation op = new DeleteResourcesOperation(
//				new IResource[] { testLinkedFolder }, "testFolderDeleteLinked",
//				false);
//		FolderSnapshot snap = new FolderSnapshot(testLinkedFolder);
//		execute(op);
//		assertFalse("Folder delete failed", testLinkedFolder.exists());
//		undo();
//		assertTrue("Folder recreation failed", testLinkedFolder.exists());
//		assertTrue("Folder content was altered on undo", snap
//				.isValid(testLinkedFolder.getParent()));
//		redo();
//		assertFalse("Redo delete failed", testLinkedFolder.exists());
//	}
//
//	public void testFileCreateLeafUndoRedo() throws ExecutionException,
//			CoreException {
//		IFile file = getWorkspaceRoot().getFile(
//				testProject.getFullPath().append(TEST_NEWFILE_NAME));
//		CreateFileOperation op = new CreateFileOperation(file, null,
//				getContents(getRandomString()), "testFileCreateLeaf");
//		assertFalse("File should not exist before test is run", file.exists());
//		execute(op);
//		assertTrue("File creation failed", file.exists());
//		FileSnapshot snapshot = new FileSnapshot(file);
//		undo();
//		assertFalse("File deletion failed", file.exists());
//		redo();
//		assertTrue("File recreation failed", file.exists());
//		assertTrue("File content improperly restored", snapshot.isValid(file
//				.getParent()));
//	}
//
//	public void testFileCreateNestedInProjectUndoRedo()
//			throws ExecutionException, CoreException {
//		// Uses file name with non-existent folder parents
//		IFile file = getWorkspaceRoot().getFile(
//				testProject.getFullPath().append(TEST_NEWNESTEDFILE_NAME));
//		CreateFileOperation op = new CreateFileOperation(file, null,
//				getContents(getRandomString()), "testFileCreateNestedInProject");
//		assertFalse("File should not exist before test is run", file.exists());
//		execute(op);
//		assertTrue("File creation failed", file.exists());
//		FileSnapshot snapshot = new FileSnapshot(file);
//
//		undo();
//		assertFalse("File deletion failed", file.exists());
//		// Ensure all created parents are gone, too
//		IPath path = new Path(TEST_NEWNESTEDFILE_NAME);
//		path.removeLastSegments(path.segmentCount() - 1);
//		IFolder parent = getWorkspaceRoot().getFolder(
//				testProject.getFullPath().append(path));
//		assertFalse("Deletion of created parents failed", parent.exists());
//
//		redo();
//		assertTrue("File recreation failed", file.exists());
//		assertTrue("File content improperly restored", snapshot.isValid(file
//				.getParent()));
//	}
//
//	public void testFileCreateNestedInFolderUndoRedo()
//			throws ExecutionException, CoreException {
//		// Uses file name with non-existent folder parents.
//		// Uses subfolder as a parent
//		IFile file = getWorkspaceRoot().getFile(
//				testSubFolder.getFullPath().append(TEST_NEWNESTEDFILE_NAME));
//		CreateFileOperation op = new CreateFileOperation(file, null,
//				getContents(getRandomString()),
//				"testFileCreateNestedInSubfolder");
//		assertFalse("File should not exist before test is run", file.exists());
//		execute(op);
//		assertTrue("File creation failed", file.exists());
//		FileSnapshot snapshot = new FileSnapshot(file);
//
//		undo();
//		assertFalse("File deletion failed", file.exists());
//		// Ensure all created parents are gone, too
//		IPath path = new Path(TEST_NEWNESTEDFILE_NAME);
//		path.removeLastSegments(path.segmentCount() - 1);
//		IFolder parent = getWorkspaceRoot().getFolder(
//				testSubFolder.getFullPath().append(path));
//		assertFalse("Deletion of created parents failed", parent.exists());
//
//		redo();
//		assertTrue("File recreation failed", file.exists());
//		assertTrue("File content improperly restored", snapshot.isValid(file
//				.getParent()));
//	}
//
//	public void testFileCreateLinkedUndoRedo() throws ExecutionException,
//			CoreException {
//		IFile file = getWorkspaceRoot().getFile(
//				testProject.getFullPath().append(TEST_NEWFILE_NAME));
//		CreateFileOperation op = new CreateFileOperation(file,
//				testFileWithContent.getLocationURI(), null,
//				"testFileCreateLink");
//		assertFalse("File should not exist before test is run", file.exists());
//
//		execute(op);
//		assertTrue("File creation failed", file.exists());
//		assertTrue("File was not created as link", file.isLinked());
//		assertEquals("Linked content not equal", readContent(file),
//				readContent(testFileWithContent));
//
//		undo();
//		assertFalse("File deletion failed", file.exists());
//
//		redo();
//		assertTrue("File was not created as link", file.isLinked());
//		assertEquals("Linked content not equal", readContent(file),
//				readContent(testFileWithContent));
//	}
//
//	public void testFileCreateLinkedNestedUndoRedo() throws ExecutionException,
//			CoreException {
//		IFile file = getWorkspaceRoot().getFile(
//				testProject.getFullPath().append(TEST_NEWNESTEDFILE_NAME));
//		CreateFileOperation op = new CreateFileOperation(file,
//				testFileWithContent.getLocationURI(), null,
//				"testFileCreateLinkNested");
//		assertFalse("File should not exist before test is run", file.exists());
//
//		execute(op);
//		assertTrue("File creation failed", file.exists());
//		assertTrue("File was not created as link", file.isLinked());
//		assertEquals("Linked content not equal", readContent(file),
//				readContent(testFileWithContent));
//
//		undo();
//		assertFalse("File deletion failed", file.exists());
//		// Ensure all created parents are gone, too
//		IPath path = new Path(TEST_NEWNESTEDFILE_NAME);
//		path.removeLastSegments(path.segmentCount() - 1);
//		IFolder parent = getWorkspaceRoot().getFolder(
//				testProject.getFullPath().append(path));
//		assertFalse("Deletion of created parents failed", parent.exists());
//
//		redo();
//		assertTrue("File was not created as link", file.isLinked());
//		assertEquals("Linked content not equal", readContent(file),
//				readContent(testFileWithContent));
//	}
//
//	public void testFileMoveUndoRedo() throws ExecutionException, CoreException {
//		// Moving from a folder in one project to the top level of another
//		// project
//		IPath targetPath = targetProject.getFullPath().append(
//				testFileWithContent.getName());
//		MoveResourcesOperation op = new MoveResourcesOperation(
//				testFileWithContent, targetPath, "testFileMove");
//		FileSnapshot snap = new FileSnapshot(testFileWithContent);
//		execute(op);
//		IFile movedFile = getWorkspaceRoot().getFile(targetPath);
//		assertTrue("File move failed", movedFile.exists());
//		assertTrue("File content was altered", snap.isValid(targetProject));
//
//		undo();
//		movedFile = getWorkspaceRoot().getFile(targetPath);
//		assertFalse("Move undo failed", movedFile.exists());
//		assertTrue("File content was altered on undo", snap.isValid(testFolder));
//
//		redo();
//		movedFile = getWorkspaceRoot().getFile(targetPath);
//		assertTrue("File move failed", movedFile.exists());
//		assertTrue("File content was altered", snap.isValid(targetProject));
//	}
//
//	public void testFileMoveAndOverwriteUndoRedo() throws ExecutionException,
//			CoreException {
//		// Moving a file from a folder inside that the same folder on top of an
//		// existent file
//		IPath sourcePath = emptyTestFile.getFullPath();
//		IPath targetPath = testFileWithContent.getFullPath();
//		MoveResourcesOperation op = new MoveResourcesOperation(emptyTestFile,
//				targetPath, "testFileMoveOverwrite");
//		FileSnapshot source = new FileSnapshot(emptyTestFile);
//		FileSnapshot overwritten = new FileSnapshot(testFileWithContent);
//		execute(op);
//		IFile sourceFile = getWorkspaceRoot().getFile(sourcePath);
//		assertFalse("File move failed", sourceFile.exists());
//		source.name = TEST_RANDOMFILE_NAME;
//		assertTrue("Source content was altered at target", source
//				.isValid(testFolder));
//
//		undo();
//		assertTrue("File restore failed", sourceFile.exists());
//		assertTrue("Overwritten file was not restored", overwritten
//				.isValid(testFolder));
//		source.name = TEST_EMPTYFILE_NAME;
//		assertTrue("Source file content was not restored", source
//				.isValid(testFolder));
//
//		redo();
//		sourceFile = getWorkspaceRoot().getFile(sourcePath);
//		assertFalse("File move failed", sourceFile.exists());
//		source.name = TEST_RANDOMFILE_NAME;
//		assertTrue("Source content was altered at target", source
//				.isValid(testFolder));
//	}
//
//	public void testFileCopyUndoRedo() throws ExecutionException, CoreException {
//		// copying with same name to a new project
//		CopyResourcesOperation op = new CopyResourcesOperation(
//				new IResource[] { testFileWithContent }, targetProject
//						.getFullPath(), "testFileCopy");
//		FileSnapshot snap = new FileSnapshot(testFileWithContent);
//		execute(op);
//		IFile copiedFile = targetProject.getFile(testFileWithContent.getName());
//		assertTrue("File copy failed", copiedFile.exists());
//		assertTrue("Source file was altered", snap.isValid(testFolder));
//		assertTrue("File copy does not match", snap.isValid(targetProject));
//
//		undo();
//		assertFalse("Copy undo failed", copiedFile.exists());
//
//		redo();
//		assertTrue("File not restored properly on redo", snap
//				.isValid(targetProject));
//		assertTrue("Source file was altered", snap.isValid(testFolder));
//	}
//
//	public void testFileCopyLinkUndoRedo() throws ExecutionException,
//			CoreException {
//		// copying with same name to a new project
//		CopyResourcesOperation op = new CopyResourcesOperation(
//				new IResource[] { testLinkedFile },
//				targetProject.getFullPath(), "testFileLinkCopy");
//		FileSnapshot snap = new FileSnapshot(testLinkedFile);
//		execute(op);
//		IFile copiedFile = targetProject.getFile(testLinkedFile.getName());
//		assertTrue("File copy failed", copiedFile.exists());
//		assertTrue("Source file was altered", snap.isValid(testFolder));
//		assertTrue("File copy does not match", snap.isValid(targetProject));
//
//		undo();
//		assertFalse("Copy undo failed", copiedFile.exists());
//
//		redo();
//		assertTrue("File not restored properly on redo", snap
//				.isValid(targetProject));
//		assertTrue("Source file was altered", snap.isValid(testFolder));
//	}
//
//	public void testFileCopyRenameUndoRedo() throws ExecutionException,
//			CoreException {
//		// copying with a different name to the same project
//		CopyResourcesOperation op = new CopyResourcesOperation(
//				testFileWithContent, testProject.getFullPath().append(
//						TEST_NEWFILE_NAME), "testFileCopyRename");
//		FileSnapshot snap = new FileSnapshot(testFileWithContent);
//		execute(op);
//
//		IFile copiedFile = testProject.getFile(TEST_NEWFILE_NAME);
//		assertTrue("File copy failed", copiedFile.exists());
//		assertTrue("Source folder was altered", snap.isValid(testFolder));
//		snap.name = TEST_NEWFILE_NAME;
//		assertTrue("File copy does not match", snap.isValid(testProject));
//
//		undo();
//		assertFalse("Copy undo failed", copiedFile.exists());
//
//		redo();
//		assertTrue("File not restored properly on redo", snap
//				.isValid(testProject));
//		snap.name = TEST_RANDOMFILE_NAME;
//		assertTrue("Source folder was altered", snap.isValid(testFolder));
//	}
//
//	public void testFileCopyAndOverwriteUndoRedo() throws ExecutionException,
//			CoreException {
//		// Copying from a file in a folder to the same folder on top of an
//		// existent file
//		IPath targetPath = testFileWithContent.getFullPath();
//		CopyResourcesOperation op = new CopyResourcesOperation(emptyTestFile,
//				targetPath, "testFileMoveOverwrite");
//		FileSnapshot source = new FileSnapshot(emptyTestFile);
//		FileSnapshot overwritten = new FileSnapshot(testFileWithContent);
//		execute(op);
//		assertTrue("Source content was altered", source.isValid(testFolder));
//		source.name = TEST_RANDOMFILE_NAME;
//		assertTrue("Source content was altered at target", source
//				.isValid(testFolder));
//
//		undo();
//		assertTrue("Overwritten file was not restored", overwritten
//				.isValid(testFolder));
//		source.name = TEST_EMPTYFILE_NAME;
//		assertTrue("Source file content was not restored", source
//				.isValid(testFolder));
//
//		redo();
//		source.name = TEST_RANDOMFILE_NAME;
//		assertTrue("Source content was altered at target", source
//				.isValid(testFolder));
//	}
//
//	public void testFileRenameUndoRedo() throws ExecutionException,
//			CoreException {
//		MoveResourcesOperation op = new MoveResourcesOperation(
//				testFileInProject, testProject.getFullPath().append(
//						TEST_NEWFILE_NAME), "testFileRename");
//		FileSnapshot snap = new FileSnapshot(testFileInProject);
//		execute(op);
//		IFile renamedFile = testProject.getFile(TEST_NEWFILE_NAME);
//		assertTrue("File rename failed", renamedFile.exists());
//		snap.name = TEST_NEWFILE_NAME;
//		assertTrue("File content was altered on rename", snap
//				.isValid(testProject));
//
//		undo();
//		snap.name = TEST_FILEINPROJECT_NAME;
//		assertTrue("File content was altered on undo rename", snap
//				.isValid(testProject));
//		assertFalse("Undo rename failed", renamedFile.exists());
//
//		redo();
//		snap.name = TEST_NEWFILE_NAME;
//		assertTrue("File content was altered on redo rename", snap
//				.isValid(testProject));
//	}
//
//	public void testFileDeleteUndoRedo() throws ExecutionException,
//			CoreException {
//		DeleteResourcesOperation op = new DeleteResourcesOperation(
//				new IResource[] { testFileWithContent }, "testFileDelete",
//				false);
//		FileSnapshot snap = new FileSnapshot(testFileWithContent);
//		execute(op);
//		assertFalse("File delete failed", testFileWithContent.exists());
//		undo();
//		assertTrue("File recreation failed", testFileWithContent.exists());
//		assertTrue("File content was altered on undo", snap
//				.isValid(testFileWithContent.getParent()));
//		redo();
//		assertFalse("Redo delete failed", testFileWithContent.exists());
//	}
//
//	public void testFileLinkedDeleteUndoRedo() throws ExecutionException,
//			CoreException {
//		DeleteResourcesOperation op = new DeleteResourcesOperation(
//				new IResource[] { testLinkedFile }, "testLinkedFileDelete",
//				false);
//		FileSnapshot snap = new FileSnapshot(testLinkedFile);
//		execute(op);
//		assertFalse("File delete failed", testLinkedFile.exists());
//		undo();
//		assertTrue("File recreation failed", testLinkedFile.exists());
//		assertTrue("File content was altered on undo", snap
//				.isValid(testLinkedFile.getParent()));
//		redo();
//		assertFalse("Redo delete failed", testLinkedFile.exists());
//	}
//
//	public void testFileAndFolderMoveSameDests() throws ExecutionException,
//			CoreException {
//		IPath targetPath = targetProject.getFullPath();
//		MoveResourcesOperation op = new MoveResourcesOperation(new IResource[] {
//				testSubFolder, testFileWithContent }, targetPath,
//				"testFileAndFolderMove");
//		FolderSnapshot snapFolder = new FolderSnapshot(testSubFolder);
//		FileSnapshot snapFile = new FileSnapshot(testFileWithContent);
//		execute(op);
//		IFolder movedFolder = getWorkspaceRoot().getFolder(
//				targetPath.append(TEST_SUBFOLDER_NAME));
//		assertTrue("Folder move failed", movedFolder.exists());
//		assertTrue("Folder content was altered", snapFolder
//				.isValid(targetProject));
//		IFile movedFile = getWorkspaceRoot().getFile(
//				targetPath.append(TEST_RANDOMFILE_NAME));
//		assertTrue("File move failed", movedFile.exists());
//		assertTrue("File content was altered", snapFile.isValid(targetProject));
//
//		undo();
//		movedFolder = getWorkspaceRoot().getFolder(
//				targetPath.append(TEST_SUBFOLDER_NAME));
//		assertFalse("Move undo failed", movedFolder.exists());
//		assertTrue("Folder content was altered on undo", snapFolder
//				.isValid(testFolder));
//		movedFile = getWorkspaceRoot().getFile(
//				targetPath.append(TEST_RANDOMFILE_NAME));
//		assertFalse("Move undo failed", movedFolder.exists());
//		assertTrue("File content was altered on undo", snapFile
//				.isValid(testFolder));
//
//		redo();
//		movedFolder = getWorkspaceRoot().getFolder(
//				targetPath.append(TEST_SUBFOLDER_NAME));
//		assertTrue("Folder move failed", movedFolder.exists());
//		assertTrue("Folder content was altered", snapFolder
//				.isValid(targetProject));
//		movedFile = getWorkspaceRoot().getFile(
//				targetPath.append(TEST_RANDOMFILE_NAME));
//		assertTrue("File move failed", movedFile.exists());
//		assertTrue("File content was altered", snapFile.isValid(targetProject));
//	}
//
//	public void testFileAndFolderCopyDifferentDests()
//			throws ExecutionException, CoreException {
//		// copying a file and folder to different destination projects,
//		// assigning new names to a new project
//		// The folder gets a new name, the file retains the old name
//		CopyResourcesOperation op = new CopyResourcesOperation(new IResource[] {
//				testSubFolder, testFileWithContent }, new IPath[] {
//				testProject.getFullPath().append(TEST_NEWFOLDER_NAME),
//				targetProject.getFullPath().append(
//						testFileWithContent.getName()) },
//				"testFileAndFolderDifferentDests");
//		FolderSnapshot snapFolder = new FolderSnapshot(testSubFolder);
//		FileSnapshot snapFile = new FileSnapshot(testFileWithContent);
//		execute(op);
//		IFolder copiedFolder = testProject.getFolder(TEST_NEWFOLDER_NAME);
//		assertTrue("Folder copy failed", copiedFolder.exists());
//		assertTrue("Source folder was altered", snapFolder.isValid(testFolder));
//		snapFolder.name = TEST_NEWFOLDER_NAME;
//		assertTrue("Folder copy does not match", snapFolder
//				.isValid(testProject));
//		IFile copiedFile = targetProject.getFile(testFileWithContent.getName());
//		assertTrue("File copy failed", copiedFile.exists());
//		assertTrue("Source file was altered", snapFile.isValid(testFolder));
//		assertTrue("File copy does not match", snapFile.isValid(targetProject));
//
//		undo();
//		assertFalse("Copy folder undo failed", copiedFolder.exists());
//		assertFalse("Copy file undo failed", copiedFile.exists());
//		snapFolder.name = testSubFolder.getName();
//		assertTrue("Source file was altered during undo", snapFile
//				.isValid(testFolder));
//		assertTrue("Source folder was altered during undo", snapFolder
//				.isValid(testFolder));
//
//		redo();
//		assertTrue("Source folder was altered during redo", snapFolder
//				.isValid(testFolder));
//		snapFolder.name = TEST_NEWFOLDER_NAME;
//		assertTrue("Folder copy does not match on redo", snapFolder
//				.isValid(testProject));
//		assertTrue("Source file was altered during redo", snapFile
//				.isValid(testFolder));
//		assertTrue("File copy does not match on redo", snapFile
//				.isValid(targetProject));
//	}
//
//	public void testFileAndFolderCopyDifferentNames()
//			throws ExecutionException, CoreException {
//		// copying a file and folder to a new project, assigning new names to a
//		// new project
//		CopyResourcesOperation op = new CopyResourcesOperation(new IResource[] {
//				testSubFolder, testFileWithContent }, new IPath[] {
//				targetProject.getFullPath().append(TEST_NEWFOLDER_NAME),
//				targetProject.getFullPath().append(TEST_NEWFILE_NAME) },
//				"testFileAndFolderDifferentNames");
//		FolderSnapshot snapFolder = new FolderSnapshot(testSubFolder);
//		FileSnapshot snapFile = new FileSnapshot(testFileWithContent);
//		execute(op);
//		IFolder copiedFolder = targetProject.getFolder(TEST_NEWFOLDER_NAME);
//		assertTrue("Folder copy failed", copiedFolder.exists());
//		assertTrue("Source folder was altered", snapFolder.isValid(testFolder));
//		snapFolder.name = TEST_NEWFOLDER_NAME;
//		assertTrue("Folder copy does not match", snapFolder
//				.isValid(targetProject));
//		IFile copiedFile = targetProject.getFile(TEST_NEWFILE_NAME);
//		assertTrue("File copy failed", copiedFile.exists());
//		assertTrue("Source file was altered", snapFile.isValid(testFolder));
//		snapFile.name = TEST_NEWFILE_NAME;
//		assertTrue("File copy does not match", snapFile.isValid(targetProject));
//
//		undo();
//		assertFalse("Copy folder undo failed", copiedFolder.exists());
//		assertFalse("Copy file undo failed", copiedFile.exists());
//		snapFolder.name = testSubFolder.getName();
//		assertTrue("Source file was altered during undo", snapFolder
//				.isValid(testFolder));
//		snapFile.name = testFileWithContent.getName();
//		assertTrue("Source folder was altered during undo", snapFile
//				.isValid(testFolder));
//
//		redo();
//		assertTrue("Source folder was altered during redo", snapFolder
//				.isValid(testFolder));
//		snapFolder.name = TEST_NEWFOLDER_NAME;
//		assertTrue("Folder copy does not match on redo", snapFolder
//				.isValid(targetProject));
//		assertTrue("Source file was altered during redo", snapFile
//				.isValid(testFolder));
//		snapFile.name = TEST_NEWFILE_NAME;
//		assertTrue("File copy does not match on redo", snapFile
//				.isValid(targetProject));
//	}
//
//	public void testRedundantFileAndFolderCopy() throws CoreException,
//			ExecutionException {
//		// copying a file which is a child of a folder, keeping same name to a new project
//		CopyResourcesOperation op = new CopyResourcesOperation(new IResource[] {
//				testFolder, testFileWithContent }, targetProject
//				.getFullPath(), "testRedundantFileAndFolderCopy");
//		FolderSnapshot snapFolder = new FolderSnapshot(testFolder);
//		FileSnapshot snapFile = new FileSnapshot(testFileWithContent);
//		execute(op);
//		IFolder copiedFolder = targetProject.getFolder(testFolder.getName());
//		assertTrue("Folder copy failed", copiedFolder.exists());
//		assertTrue("Source folder was altered", snapFolder.isValid(testProject));
//		assertTrue("Folder copy does not match", snapFolder
//				.isValid(targetProject));
//		IFile copiedFile = targetProject.getFile(testFileWithContent.getName());
//		assertFalse("Nested file should not have been copied to new location", copiedFile.exists());
//		copiedFile = testFolder.getFile(testFileWithContent.getName());
//		assertTrue("Nested file should have been copied to existing parent", copiedFile.exists());
//		assertTrue("Source file was altered", snapFile.isValid(testFolder));
//
//		undo();
//		assertFalse("Copy folder undo failed", copiedFolder.exists());
//		assertTrue("Source file was altered during undo", snapFile
//				.isValid(testFolder));
//		assertTrue("Source folder was altered during undo", snapFolder
//				.isValid(testProject));
//
//		redo();
//		assertTrue("Source folder was altered during redo", snapFolder
//				.isValid(testProject));
//		assertTrue("Folder copy does not match on redo", snapFolder
//				.isValid(targetProject));
//		assertTrue("Source file was altered during redo", snapFile
//				.isValid(testFolder));
//	}
//
//	public void testFileAndFolderCopySameDests() throws ExecutionException,
//			CoreException {
//		// copying a file and folder, keeping same name to a new project
//		CopyResourcesOperation op = new CopyResourcesOperation(new IResource[] {
//				testSubFolder, testFileWithContent }, targetProject
//				.getFullPath(), "testFileAndFolderCopy");
//		FolderSnapshot snapFolder = new FolderSnapshot(testSubFolder);
//		FileSnapshot snapFile = new FileSnapshot(testFileWithContent);
//		execute(op);
//		IFolder copiedFolder = targetProject.getFolder(testSubFolder.getName());
//		assertTrue("Folder copy failed", copiedFolder.exists());
//		assertTrue("Source folder was altered", snapFolder.isValid(testFolder));
//		assertTrue("Folder copy does not match", snapFolder
//				.isValid(targetProject));
//		IFile copiedFile = targetProject.getFile(testFileWithContent.getName());
//		assertTrue("File copy failed", copiedFile.exists());
//		assertTrue("Source file was altered", snapFile.isValid(testFolder));
//		assertTrue("File copy does not match", snapFile.isValid(targetProject));
//
//		undo();
//		assertFalse("Copy folder undo failed", copiedFolder.exists());
//		assertFalse("Copy file undo failed", copiedFile.exists());
//		assertTrue("Source file was altered during undo", snapFile
//				.isValid(testFolder));
//		assertTrue("Source folder was altered during undo", snapFolder
//				.isValid(testFolder));
//
//		redo();
//		assertTrue("Source folder was altered during redo", snapFolder
//				.isValid(testFolder));
//		assertTrue("Folder copy does not match on redo", snapFolder
//				.isValid(targetProject));
//		assertTrue("Source file was altered during redo", snapFile
//				.isValid(testFolder));
//		assertTrue("File copy does not match on redo", snapFile
//				.isValid(targetProject));
//	}
//
//	public void testWorkspaceUndoMonitor() throws ExecutionException,
//			CoreException {
//		// First we copy the project to the target location
//		// This gives us lots of stuff to delete in order to manufacture some
//		// workspace changes
//		CopyProjectOperation op = new CopyProjectOperation(testProject,
//				TEST_NEWPROJECT_NAME, null, "testProjectCopy");
//		execute(op);
//		// Now we are going to create a new file
//		IFile file = getWorkspaceRoot().getFile(
//				testProject.getFullPath().append(TEST_NEWFILE_NAME));
//		CreateFileOperation op2 = new CreateFileOperation(file, null,
//				getContents(getRandomString()), "testFileCreateLeaf");
//		execute(op2);
//		assertTrue("Operation should be valid", op2.canUndo());
//		int changes = 0;
//		// back door delete the new file
//		file.delete(true, getMonitor());
//		changes++;
//		// op still doesn't know it's invalid because undo monitor hasn't
//		// had changes to force checking it.
//		assertTrue("Operation should be valid", op2.canUndo());
//
//		// Now perform a bunch of changes
//		emptyTestFile.delete(true, getMonitor());
//		changes++;
//		testFileInProject.delete(true, getMonitor());
//		changes++;
//		testFileInSubFolder.delete(true, getMonitor());
//		changes++;
//		testFileWithContent.delete(true, getMonitor());
//		changes++;
//		testLinkedFile.delete(true, getMonitor());
//		changes++;
//		testLinkedFolder.delete(true, getMonitor());
//		changes++;
//		testSubFolder.delete(true, getMonitor());
//		changes++;
//		testFolder.delete(true, getMonitor());
//		changes++;
//		testFolder = testProject.getFolder(TEST_FOLDER_NAME);
//		testFolder.create(true, true, getMonitor());
//		changes++;
//		testFileInProject = testProject.getFile(TEST_FILEINPROJECT_NAME);
//		testFileInProject.create(getContents(getRandomString()), true,
//				getMonitor());
//		changes++;
//		testSubFolder = testFolder.getFolder(TEST_SUBFOLDER_NAME);
//		testSubFolder.create(true, true, getMonitor());
//		changes++;
//		emptyTestFile = testFolder.getFile(TEST_EMPTYFILE_NAME);
//		emptyTestFile.create(getContents(FILE_CONTENTS_EMPTY), true,
//				getMonitor());
//		changes++;
//
//		assertTrue("Need to make at least the minimum number of changes",
//				changes >= NUM_CHANGES);
//		assertFalse("Operation should be invalid", op2.canUndo());
//	}
//
//	public void testProjectCopyUndoInvalid() throws ExecutionException,
//			CoreException {
//		// Create a new copy of a project
//		CopyProjectOperation op = new CopyProjectOperation(testProject,
//				TEST_NEWPROJECT_NAME, null, "testProjectCopyUndoInvalid");
//		execute(op);
//		// Now we "back door" delete one of the files in the source project
//		emptyTestFile.delete(true, getMonitor());
//		// The operation should know that undoing is dangerous
//		undoExpectFail(op);
//	}
//
//	public void test162655() throws ExecutionException, CoreException {
//		DeleteResourcesOperation op = new DeleteResourcesOperation(
//				new IResource[] { testProject }, "testProjectDelete", false);
//		execute(op);
//		assertFalse("Project delete failed", testProject.exists());
//
//		// recreate outside the scope of undo
//		testProject = getWorkspace().getRoot().getProject(TEST_PROJECT_NAME);
//		testProject.create(getMonitor());
//		testProject.open(getMonitor());
//		assertTrue("Project creation failed", testProject.exists());
//
//		// Now that project exists again, the undo should fail.
//		undoExpectFail(op);
//	}
//}