Don't return a path for an IStorage representing an index entry

Doing so may make some parts of Eclipse conclude the storage really
represented an on-disk file and then revert the internal file buffer
to that index state, which rolls back all open editors on that file
to the index state (and marks them dirty). That's not what we want
at all. Occurs for instance with Java files.

Adapting to IFile (from commit 0c17469b) to make Eclipse select the
right DocumentProvider is fine, but returning a path for the IStorage
is not.

Bug: 550989
Change-Id: I3f63ad9a4432063d7d1a245c05641fcf12698c2f
Signed-off-by: Thomas Wolf <thomas.wolf@paranor.ch>

6 files changed, 365 insertions, 205 deletions

diff --git a/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/common/CompareEditorTester.java b/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/common/CompareEditorTester.java
index 687a8d09be..940bf96314 100644
--- a/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/common/CompareEditorTester.java
+++ b/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/common/CompareEditorTester.java
@@ -48,6 +48,10 @@ public class CompareEditorTester {
 		return getNonAncestorEditor(1);
 	}
 
+	public boolean isDirty() {
+		return editor.isDirty();
+	}
+
 	public void save() {
 		editor.save();
 	}
diff --git a/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/common/JavaProjectTester.java b/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/common/JavaProjectTester.java
new file mode 100644
index 0000000000..eb602c628a
--- /dev/null
+++ b/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/common/JavaProjectTester.java
@@ -0,0 +1,229 @@
+/*******************************************************************************
+ * Copyright (C) 2019, Thomas Wolf <thomas.wolf@paranor.ch>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.egit.ui.common;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IFolder;
+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.IWorkspaceDescription;
+import org.eclipse.core.resources.IWorkspaceRoot;
+import org.eclipse.core.resources.IWorkspaceRunnable;
+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.Path;
+import org.eclipse.egit.core.Activator;
+import org.eclipse.egit.core.internal.indexdiff.IndexDiffCache;
+import org.eclipse.egit.core.op.CommitOperation;
+import org.eclipse.egit.core.op.ConnectProviderOperation;
+import org.eclipse.egit.ui.test.TestUtil;
+import org.eclipse.jdt.core.IClasspathEntry;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IPackageFragment;
+import org.eclipse.jdt.core.IPackageFragmentRoot;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.launching.JavaRuntime;
+import org.eclipse.jgit.lib.Repository;
+
+public class JavaProjectTester {
+
+	public static final String JAVA_PROJECT_NAME = "javatestProject";
+
+	public static final String SRC_FOLDER_NAME = "src";
+
+	public static final String BIN_FOLDER_NAME = "bin";
+
+	public static final String PACKAGE_NAME = "p";
+
+	public static final String JAVA_CLASS_NAME = "A";
+
+	public static final String JAVA_FILE_NAME = JAVA_CLASS_NAME + ".java";
+
+	public static final String JAVA_FILE_PATH = JAVA_PROJECT_NAME + '/'
+			+ SRC_FOLDER_NAME + '/' + PACKAGE_NAME + '/' + JAVA_FILE_NAME;
+
+	public static final String INITIAL_FILE_CONTENT = "package " + PACKAGE_NAME
+			+ ";\nclass " + JAVA_CLASS_NAME + " {\n\n}";
+
+	private static final int MAX_DELETE_RETRY = 5;
+
+	private static final int DELETE_RETRY_DELAY = 1000; // ms
+
+	private final LocalRepositoryTestCase testCase;
+
+	public JavaProjectTester(LocalRepositoryTestCase testCase) {
+		this.testCase = testCase;
+	}
+
+	public static boolean setAutobuild(boolean value) throws CoreException {
+		IWorkspace workspace = ResourcesPlugin.getWorkspace();
+		IWorkspaceDescription desc = workspace.getDescription();
+		boolean isAutoBuilding = desc.isAutoBuilding();
+		if (isAutoBuilding != value) {
+			desc.setAutoBuilding(value);
+			workspace.setDescription(desc);
+		}
+		return isAutoBuilding;
+	}
+
+	public IJavaProject createJavaProjectAndCommitToRepository()
+			throws Exception {
+		Repository myRepository = testCase
+				.createLocalTestRepository(LocalRepositoryTestCase.REPO1);
+		File gitDir = myRepository.getDirectory();
+		IJavaProject jProject = createJavaProject(myRepository,
+				JAVA_PROJECT_NAME);
+		IProject project = jProject.getProject();
+		try {
+			new ConnectProviderOperation(project, gitDir).execute(null);
+		} catch (Exception e) {
+			Activator.logError("Failed to connect project to repository", e);
+		}
+		testCase.assertConnected(project);
+		// Check in at least the java file
+		IFolder folder = project.getFolder(SRC_FOLDER_NAME)
+				.getFolder(PACKAGE_NAME);
+		IFile file = folder.getFile(JAVA_FILE_NAME);
+
+		IFile[] commitables = new IFile[] { file };
+		ArrayList<IFile> untracked = new ArrayList<>();
+		untracked.addAll(Arrays.asList(commitables));
+		// commit to master
+		CommitOperation op = new CommitOperation(commitables, untracked,
+				TestUtil.TESTAUTHOR, TestUtil.TESTCOMMITTER, "Initial commit");
+		op.execute(null);
+
+		// Make sure cache entry is already listening for changes
+		IndexDiffCache cache = Activator.getDefault().getIndexDiffCache();
+		cache.getIndexDiffCacheEntry(Activator.getDefault().getRepositoryCache()
+				.lookupRepository(gitDir));
+		return jProject;
+	}
+
+	private IJavaProject createJavaProject(final Repository repository,
+			final String projectName) throws Exception {
+		final IJavaProject[] jProjectHolder = new IJavaProject[] { null };
+		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {
+			@Override
+			public void run(IProgressMonitor monitor) throws CoreException {
+				IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
+				IProject project = root.getProject(projectName);
+				if (project.exists()) {
+					project.delete(true, null);
+					TestUtil.waitForJobs(100, 5000);
+				}
+				IProjectDescription desc = ResourcesPlugin.getWorkspace()
+						.newProjectDescription(projectName);
+				desc.setLocation(
+						new Path(new File(repository.getWorkTree(), projectName)
+								.getPath()));
+				project.create(desc, null);
+				project.open(null);
+				TestUtil.waitForJobs(50, 5000);
+				// Create a "bin" folder
+				IFolder bin = project.getFolder(BIN_FOLDER_NAME);
+				if (!bin.exists()) {
+					bin.create(IResource.FORCE | IResource.DERIVED, true, null);
+				}
+				IPath outputLocation = bin.getFullPath();
+				// Create a "src" folder
+				IFolder src = project.getFolder(SRC_FOLDER_NAME);
+				if (!src.exists()) {
+					src.create(IResource.FORCE, true, null);
+				}
+				addNatureToProject(project, JavaCore.NATURE_ID);
+				// Set up the IJavaProject
+				IJavaProject jProject = JavaCore.create(project);
+				IPackageFragmentRoot srcContainer = jProject
+						.getPackageFragmentRoot(src);
+				IClasspathEntry srcEntry = JavaCore
+						.newSourceEntry(srcContainer.getPath());
+				// Create a JRE classpath entry using the default JRE
+				IClasspathEntry jreEntry = JavaRuntime
+						.getDefaultJREContainerEntry();
+				jProject.setRawClasspath(
+						new IClasspathEntry[] { srcEntry, jreEntry },
+						outputLocation, true, null);
+				// Create a package with a single test class
+				IPackageFragment javaPackage = srcContainer
+						.createPackageFragment(PACKAGE_NAME, true, null);
+				javaPackage
+						.createCompilationUnit(JAVA_FILE_NAME,
+								INITIAL_FILE_CONTENT, true, null);
+				jProjectHolder[0] = jProject;
+			}
+		};
+		ResourcesPlugin.getWorkspace().run(runnable, null);
+		return jProjectHolder[0];
+	}
+
+	private void addNatureToProject(IProject proj, String natureId)
+			throws CoreException {
+		IProjectDescription description = proj.getDescription();
+		String[] prevNatures = description.getNatureIds();
+		String[] newNatures = new String[prevNatures.length + 1];
+		System.arraycopy(prevNatures, 0, newNatures, 0, prevNatures.length);
+		newNatures[prevNatures.length] = natureId;
+		description.setNatureIds(newNatures);
+		proj.setDescription(description, null);
+	}
+
+	public void removeJavaProject(IJavaProject javaProject)
+			throws CoreException {
+		if (javaProject == null) {
+			return;
+		}
+		final IProject project = javaProject.getProject();
+		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {
+			@Override
+			public void run(IProgressMonitor monitor) throws CoreException {
+				// Following code inspired by {@link
+				// org.eclipse.jdt.testplugin.JavaProjectHelper#delete(IResource)}.
+				// I don't like all this sleeping at all, but apparently it's
+				// needed because the Java indexer might still run and hold on
+				// to some resources.
+				for (int i = 0; i < MAX_DELETE_RETRY; i++) {
+					try {
+						project.delete(IResource.FORCE
+								| IResource.ALWAYS_DELETE_PROJECT_CONTENT,
+								null);
+						break;
+					} catch (CoreException e) {
+						if (i == MAX_DELETE_RETRY - 1) {
+							throw e;
+						}
+						try {
+							Activator.logInfo(
+									"Sleep before retrying to delete project "
+											+ project.getLocationURI());
+							// Give other threads the time to close and release
+							// the resource.
+							Thread.sleep(DELETE_RETRY_DELAY);
+						} catch (InterruptedException e1) {
+							// Ignore and retry to delete
+						}
+					}
+				}
+
+			}
+		};
+		ResourcesPlugin.getWorkspace().run(runnable, null);
+	}
+
+}
diff --git a/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/common/StagingViewTester.java b/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/common/StagingViewTester.java
index 232f7c79a5..9d2d2c9e89 100644
--- a/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/common/StagingViewTester.java
+++ b/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/common/StagingViewTester.java
@@ -74,6 +74,18 @@ public class StagingViewTester {
 				.setText(message);
 	}
 
+	public void compareWithIndex(String path) {
+		SWTBotTree unstagedTree = stagingView.bot().tree(0);
+
+		TestUtil.waitUntilTreeHasNodeContainsText(stagingView.bot(),
+				unstagedTree, path, 10000);
+
+		TestUtil.getNode(unstagedTree.getAllItems(), path).select();
+
+		ContextMenuHelper.clickContextMenuSync(unstagedTree,
+				UIText.StagingView_CompareWithIndexMenuLabel);
+	}
+
 	public void stageFile(String path) {
 		SWTBotTree unstagedTree = stagingView.bot().tree(0);
 
diff --git a/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/test/team/actions/JavaCompareTest.java b/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/test/team/actions/JavaCompareTest.java
new file mode 100644
index 0000000000..17bca46f00
--- /dev/null
+++ b/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/test/team/actions/JavaCompareTest.java
@@ -0,0 +1,106 @@
+/*******************************************************************************
+ * Copyright (C) 2019, Thomas Wolf <thomas.wolf@paranor.ch>
+ *
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.egit.ui.test.team.actions;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UncheckedIOException;
+import java.nio.charset.StandardCharsets;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.egit.core.JobFamilies;
+import org.eclipse.egit.ui.common.CompareEditorTester;
+import org.eclipse.egit.ui.common.JavaProjectTester;
+import org.eclipse.egit.ui.common.LocalRepositoryTestCase;
+import org.eclipse.egit.ui.common.StagingViewTester;
+import org.eclipse.egit.ui.test.TestUtil;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.swtbot.swt.finder.widgets.SWTBotTree;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class JavaCompareTest extends LocalRepositoryTestCase {
+
+	private static boolean initialAutobuild;
+
+	private IJavaProject javaProject = null;
+
+	private JavaProjectTester javaTestHelper;
+
+	@BeforeClass
+	public static void setupAutobuildOff() throws CoreException {
+		// Switch off autobuild -- we don't need it, and a build job might
+		// interfere with our removing the Java project at the end.
+		initialAutobuild = JavaProjectTester.setAutobuild(false);
+	}
+
+	@AfterClass
+	public static void teardownAutobuildReset() throws CoreException {
+		JavaProjectTester.setAutobuild(initialAutobuild);
+	}
+
+	@Before
+	public void setup() throws Exception {
+		javaTestHelper = new JavaProjectTester(this);
+		javaProject = javaTestHelper.createJavaProjectAndCommitToRepository();
+	}
+
+	@After
+	public void teardown() throws CoreException {
+		javaTestHelper.removeJavaProject(javaProject);
+	}
+
+	@Test
+	public void testJavaCompareWithIndex() throws Exception {
+		IProject project = javaProject.getProject();
+		IFile file = project.getFolder(JavaProjectTester.SRC_FOLDER_NAME)
+				.getFolder(JavaProjectTester.PACKAGE_NAME)
+				.getFile(JavaProjectTester.JAVA_FILE_NAME);
+		String newContent = JavaProjectTester.INITIAL_FILE_CONTENT
+				+ "\n// Comment\n";
+		ResourcesPlugin.getWorkspace().run(monitor -> {
+			try (InputStream s = new ByteArrayInputStream(
+					newContent.getBytes(StandardCharsets.UTF_8))) {
+				file.setContents(s, IResource.FORCE, monitor);
+			} catch (IOException e) {
+				throw new UncheckedIOException(e);
+			}
+		}, file, IResource.NONE, null);
+		TestUtil.joinJobs(JobFamilies.INDEX_DIFF_CACHE_UPDATE);
+		// Select the project to ensure the staging view does have a repo.
+		SWTBotTree projectExplorerTree = TestUtil.getExplorerTree();
+		getProjectItem(projectExplorerTree, project.getName()).select();
+		StagingViewTester stagingViewTester = StagingViewTester
+				.openStagingView();
+		stagingViewTester.compareWithIndex(JavaProjectTester.JAVA_FILE_PATH);
+		CompareEditorTester editor = CompareEditorTester
+				.forTitleContaining(JavaProjectTester.JAVA_FILE_NAME);
+		String actualContent = editor.getLeftEditor().getText();
+		boolean isDirty = editor.isDirty();
+		if (isDirty) {
+			editor.save();
+		}
+		editor.close();
+		assertEquals(newContent, actualContent);
+		assertFalse(isDirty);
+	}
+}
diff --git a/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/test/team/actions/ShowBlameActionHandlerTest.java b/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/test/team/actions/ShowBlameActionHandlerTest.java
index 1844ae4a91..a80fe57c0e 100644
--- a/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/test/team/actions/ShowBlameActionHandlerTest.java
+++ b/org.eclipse.egit.ui.test/src/org/eclipse/egit/ui/test/team/actions/ShowBlameActionHandlerTest.java
@@ -16,42 +16,19 @@ import static org.junit.Assert.assertTrue;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
-import java.io.File;
-import java.util.ArrayList;
-import java.util.Arrays;
-
 import org.eclipse.core.resources.IFile;
-import org.eclipse.core.resources.IFolder;
 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.IWorkspaceDescription;
-import org.eclipse.core.resources.IWorkspaceRoot;
-import org.eclipse.core.resources.IWorkspaceRunnable;
-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.Path;
-import org.eclipse.egit.core.Activator;
-import org.eclipse.egit.core.internal.indexdiff.IndexDiffCache;
-import org.eclipse.egit.core.op.CommitOperation;
-import org.eclipse.egit.core.op.ConnectProviderOperation;
+import org.eclipse.egit.ui.common.JavaProjectTester;
 import org.eclipse.egit.ui.common.LocalRepositoryTestCase;
 import org.eclipse.egit.ui.internal.actions.ShowBlameActionHandler;
-import org.eclipse.egit.ui.test.TestUtil;
-import org.eclipse.jdt.core.IClasspathEntry;
 import org.eclipse.jdt.core.ICompilationUnit;
 import org.eclipse.jdt.core.IJavaElement;
 import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.jdt.core.IPackageFragment;
-import org.eclipse.jdt.core.IPackageFragmentRoot;
 import org.eclipse.jdt.core.IType;
 import org.eclipse.jdt.core.JavaCore;
-import org.eclipse.jdt.launching.JavaRuntime;
 import org.eclipse.jface.viewers.IStructuredSelection;
-import org.eclipse.jgit.lib.Repository;
 import org.junit.After;
 import org.junit.AfterClass;
 import org.junit.Before;
@@ -73,54 +50,42 @@ import org.mockito.junit.MockitoJUnitRunner;
 @RunWith(MockitoJUnitRunner.class)
 public class ShowBlameActionHandlerTest extends LocalRepositoryTestCase {
 
-	private static final String JAVA_PROJECT_NAME = "javatestProject";
-
-	private static final String SRC_FOLDER_NAME = "src";
-
-	private static final String BIN_FOLDER_NAME = "bin";
-
-	private static final String PACKAGE_NAME = "p";
-
-	private static final String JAVA_CLASS_NAME = "A";
-
-	private static final String JAVA_FILE_NAME = JAVA_CLASS_NAME + ".java";
-
-	private static final int MAX_DELETE_RETRY = 5;
-
-	private static final int DELETE_RETRY_DELAY = 1000; // ms
-
 	private static boolean initialAutobuild;
 
 	private IJavaProject javaProject = null;
 
+	private JavaProjectTester javaTestHelper;
+
 	@BeforeClass
 	public static void setupAutobuildOff() throws CoreException {
 		// Switch off autobuild -- we don't need it, and a build job might
 		// interfere with our removing the Java project at the end.
-		initialAutobuild = setAutobuild(false);
+		initialAutobuild = JavaProjectTester.setAutobuild(false);
 	}
 
 	@AfterClass
 	public static void teardownAutobuildReset() throws CoreException {
-		setAutobuild(initialAutobuild);
+		JavaProjectTester.setAutobuild(initialAutobuild);
 	}
 
 	@Before
 	public void setup() throws Exception {
-		javaProject = createJavaProjectAndCommitToRepository();
+		javaTestHelper = new JavaProjectTester(this);
+		javaProject = javaTestHelper.createJavaProjectAndCommitToRepository();
 	}
 
 	@After
 	public void teardown() throws CoreException {
-		removeJavaProject();
+		javaTestHelper.removeJavaProject(javaProject);
 	}
 
 	@Test
 	public void testShowAnnotationsFromProjectExplorer() throws Exception {
 		IProject project = javaProject.getProject();
 		// Find the file
-		IFile file = project.getFolder(SRC_FOLDER_NAME).getFolder(PACKAGE_NAME)
-				.getFile(JAVA_FILE_NAME);
+		IFile file = project.getFolder(JavaProjectTester.SRC_FOLDER_NAME)
+				.getFolder(JavaProjectTester.PACKAGE_NAME)
+				.getFile(JavaProjectTester.JAVA_FILE_NAME);
 		assertBlameEnabled(file, true);
 		// Now repeat the same with the ICompilationUnit.
 		IJavaElement element = JavaCore.create(file, javaProject);
@@ -128,7 +93,8 @@ public class ShowBlameActionHandlerTest extends LocalRepositoryTestCase {
 				element instanceof ICompilationUnit);
 		assertBlameEnabled(element, true);
 		// And with IType...
-		IType type = javaProject.findType(PACKAGE_NAME, JAVA_CLASS_NAME);
+		IType type = javaProject.findType(JavaProjectTester.PACKAGE_NAME,
+				JavaProjectTester.JAVA_CLASS_NAME);
 		assertBlameEnabled(type, true);
 		// ... and finally with something that doesn't adapt to IResource:
 		assertBlameEnabled(this, false);
@@ -146,160 +112,4 @@ public class ShowBlameActionHandlerTest extends LocalRepositoryTestCase {
 				blame.isEnabled());
 	}
 
-	// Java stuff below
-
-	private static boolean setAutobuild(boolean value) throws CoreException {
-		IWorkspace workspace = ResourcesPlugin.getWorkspace();
-		IWorkspaceDescription desc = workspace.getDescription();
-		boolean isAutoBuilding = desc.isAutoBuilding();
-		if (isAutoBuilding != value) {
-			desc.setAutoBuilding(value);
-			workspace.setDescription(desc);
-		}
-		return isAutoBuilding;
-	}
-
-	private IJavaProject createJavaProjectAndCommitToRepository()
-			throws Exception {
-		Repository myRepository = createLocalTestRepository(REPO1);
-		File gitDir = myRepository.getDirectory();
-		IJavaProject jProject = createJavaProject(myRepository,
-				JAVA_PROJECT_NAME);
-		IProject project = jProject.getProject();
-		try {
-			new ConnectProviderOperation(project, gitDir).execute(null);
-		} catch (Exception e) {
-			Activator.logError("Failed to connect project to repository", e);
-		}
-		assertConnected(project);
-		// Check in at least the java file
-		IFolder folder = project.getFolder(SRC_FOLDER_NAME)
-				.getFolder(PACKAGE_NAME);
-		IFile file = folder.getFile(JAVA_FILE_NAME);
-
-		IFile[] commitables = new IFile[] { file };
-		ArrayList<IFile> untracked = new ArrayList<IFile>();
-		untracked.addAll(Arrays.asList(commitables));
-		// commit to master
-		CommitOperation op = new CommitOperation(commitables, untracked,
-				TestUtil.TESTAUTHOR, TestUtil.TESTCOMMITTER, "Initial commit");
-		op.execute(null);
-
-		// Make sure cache entry is already listening for changes
-		IndexDiffCache cache = Activator.getDefault().getIndexDiffCache();
-		cache.getIndexDiffCacheEntry(lookupRepository(gitDir));
-		return jProject;
-	}
-
-	private IJavaProject createJavaProject(final Repository repository,
-			final String projectName) throws Exception {
-		final IJavaProject[] jProjectHolder = new IJavaProject[] { null };
-		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {
-			@Override
-			public void run(IProgressMonitor monitor) throws CoreException {
-				IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
-				IProject project = root.getProject(projectName);
-				if (project.exists()) {
-					project.delete(true, null);
-					TestUtil.waitForJobs(100, 5000);
-				}
-				IProjectDescription desc = ResourcesPlugin.getWorkspace()
-						.newProjectDescription(projectName);
-				desc.setLocation(
-						new Path(new File(repository.getWorkTree(), projectName)
-								.getPath()));
-				project.create(desc, null);
-				project.open(null);
-				TestUtil.waitForJobs(50, 5000);
-				// Create a "bin" folder
-				IFolder bin = project.getFolder(BIN_FOLDER_NAME);
-				if (!bin.exists()) {
-					bin.create(IResource.FORCE | IResource.DERIVED, true, null);
-				}
-				IPath outputLocation = bin.getFullPath();
-				// Create a "src" folder
-				IFolder src = project.getFolder(SRC_FOLDER_NAME);
-				if (!src.exists()) {
-					src.create(IResource.FORCE, true, null);
-				}
-				addNatureToProject(project, JavaCore.NATURE_ID);
-				// Set up the IJavaProject
-				IJavaProject jProject = JavaCore.create(project);
-				IPackageFragmentRoot srcContainer = jProject
-						.getPackageFragmentRoot(src);
-				IClasspathEntry srcEntry = JavaCore
-						.newSourceEntry(srcContainer.getPath());
-				// Create a JRE classpath entry using the default JRE
-				IClasspathEntry jreEntry = JavaRuntime
-						.getDefaultJREContainerEntry();
-				jProject.setRawClasspath(
-						new IClasspathEntry[] { srcEntry, jreEntry },
-						outputLocation, true, null);
-				// Create a package with a single test class
-				IPackageFragment javaPackage = srcContainer
-						.createPackageFragment(PACKAGE_NAME, true, null);
-				javaPackage
-						.createCompilationUnit(JAVA_FILE_NAME,
-								"package " + PACKAGE_NAME + ";\nclass "
-										+ JAVA_CLASS_NAME + " {\n\n}",
-								true, null);
-				jProjectHolder[0] = jProject;
-			}
-		};
-		ResourcesPlugin.getWorkspace().run(runnable, null);
-		return jProjectHolder[0];
-	}
-
-	private void addNatureToProject(IProject proj, String natureId)
-			throws CoreException {
-		IProjectDescription description = proj.getDescription();
-		String[] prevNatures = description.getNatureIds();
-		String[] newNatures = new String[prevNatures.length + 1];
-		System.arraycopy(prevNatures, 0, newNatures, 0, prevNatures.length);
-		newNatures[prevNatures.length] = natureId;
-		description.setNatureIds(newNatures);
-		proj.setDescription(description, null);
-	}
-
-	private void removeJavaProject() throws CoreException {
-		if (javaProject == null) {
-			return;
-		}
-		final IProject project = javaProject.getProject();
-		IWorkspaceRunnable runnable = new IWorkspaceRunnable() {
-			@Override
-			public void run(IProgressMonitor monitor) throws CoreException {
-				// Following code inspired by {@link
-				// org.eclipse.jdt.testplugin.JavaProjectHelper#delete(IResource)}.
-				// I don't like all this sleeping at all, but apparently it's
-				// needed because the Java indexer might still run and hold on
-				// to some resources.
-				for (int i = 0; i < MAX_DELETE_RETRY; i++) {
-					try {
-						project.delete(
-								IResource.FORCE
-										| IResource.ALWAYS_DELETE_PROJECT_CONTENT,
-								null);
-						break;
-					} catch (CoreException e) {
-						if (i == MAX_DELETE_RETRY - 1) {
-							throw e;
-						}
-						try {
-							Activator.logInfo(
-									"Sleep before retrying to delete project "
-											+ project.getLocationURI());
-							// Give other threads the time to close and release
-							// the resource.
-							Thread.sleep(DELETE_RETRY_DELAY);
-						} catch (InterruptedException e1) {
-							// Ignore and retry to delete
-						}
-					}
-				}
-
-			}
-		};
-		ResourcesPlugin.getWorkspace().run(runnable, null);
-	}
 }
diff --git a/org.eclipse.egit.ui/src/org/eclipse/egit/ui/internal/revision/EditableRevision.java b/org.eclipse.egit.ui/src/org/eclipse/egit/ui/internal/revision/EditableRevision.java
index fef6ae91f5..c31a8de485 100644
--- a/org.eclipse.egit.ui/src/org/eclipse/egit/ui/internal/revision/EditableRevision.java
+++ b/org.eclipse.egit.ui/src/org/eclipse/egit/ui/internal/revision/EditableRevision.java
@@ -26,7 +26,6 @@ import org.eclipse.core.resources.IEncodedStorage;
 import org.eclipse.core.resources.IStorage;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IPath;
-import org.eclipse.core.runtime.Path;
 import org.eclipse.egit.core.internal.SafeRunnable;
 import org.eclipse.egit.ui.Activator;
 import org.eclipse.egit.ui.internal.UIText;
@@ -351,7 +350,7 @@ public class EditableRevision extends FileRevisionTypedElement implements
 
 					@Override
 					public IPath getFullPath() {
-						return new Path(editable.getPath());
+						return null;
 					}
 
 					@Override