tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/regression/Bug_026294.java - platform/eclipse.platform.resources - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2015 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.core.tests.resources.regression;

 import java.io.*;
 import junit.framework.Test;
 import junit.framework.TestSuite;
 import org.eclipse.core.resources.*;
 import org.eclipse.core.runtime.*;
 import org.eclipse.core.tests.resources.ResourceTest;

 /**
  * A parent container (projects and folders) would become out-of-sync if any of
  * its children could not be deleted for some reason. These platform-
  * specific test cases ensure that it does not happen.
  */
 public class Bug_026294 extends ResourceTest {

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

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

 	/**
 	 * Tries to delete an open project containing an unremovable file.
 	 * Works only for Windows.
 	 */
 	public void testDeleteOpenProjectWindows() {
 		if (!(isWindows())) {
 			return;
 		}

 		IProject project = null;
 		InputStream input = null;
 		File projectRoot = null;
 		try {
 			IWorkspace workspace = getWorkspace();
 			project = workspace.getRoot().getProject(getUniqueString());
 			IFolder folder = project.getFolder("a_folder");
 			IFile file1 = folder.getFile("file1.txt");
 			IFile file2 = project.getFile("file2.txt");
 			IFile file3 = folder.getFile("file3.txt");
 			IFile projectFile = project.getFile(new Path(".project"));

 			ensureExistsInWorkspace(new IResource[] {file1, file2, file3}, true);
 			projectRoot = project.getLocation().toFile();

 			assertExistsInFileSystem("0.0", file1);
 			assertExistsInFileSystem("0.1", file2);
 			assertExistsInFileSystem("0.2", file3);
 			assertExistsInFileSystem("0.3", folder);
 			assertExistsInFileSystem("0.4", projectFile);

 			// opens a file so it cannot be removed on Windows
 			try {
 				input = file1.getContents();
 			} catch (CoreException ce) {
 				ce.printStackTrace();
 				fail("1.0");
 			}
 			assertTrue("1.2", projectFile.exists());
 			assertTrue("1.3", projectFile.isSynchronized(IResource.DEPTH_INFINITE));

 			try {
 				project.delete(IResource.FORCE, getMonitor());
 				fail("2.0 - should have failed");
 			} catch (CoreException ce) {
 				// success - a file couldn't be removed
 			}

 			// Delete is best-case so check all the files.
 			// Do a check on disk and in the workspace in case something is out of sync.
 			assertExistsInWorkspace("2.1.1", project);
 			assertExistsInFileSystem("2.1.2", project);

 			assertExistsInWorkspace("2.2.1", file1);
 			assertExistsInFileSystem("2.2.2", file1);
 			assertTrue("2.2.3", file1.isSynchronized(IResource.DEPTH_INFINITE));

 			assertDoesNotExistInWorkspace("2.3.1", file2);
 			assertDoesNotExistInFileSystem("2.3.2", file2);
 			assertTrue("2.3.3", file2.isSynchronized(IResource.DEPTH_INFINITE));

 			assertDoesNotExistInWorkspace("2.4.1", file3);
 			assertDoesNotExistInFileSystem("2.4.2", file3);
 			assertTrue("2.4.3", file3.isSynchronized(IResource.DEPTH_INFINITE));

 			assertExistsInWorkspace("2.5.1", folder);
 			assertExistsInFileSystem("2.5.2", folder);
 			assertTrue("2.5.3", folder.isSynchronized(IResource.DEPTH_INFINITE));

 			assertExistsInWorkspace("2.6.1", projectFile);
 			assertExistsInFileSystem("2.6.2", projectFile);
 			assertTrue("2.6.3", projectFile.isSynchronized(IResource.DEPTH_INFINITE));

 			assertTrue("2.7.0", project.isSynchronized(IResource.DEPTH_ZERO));
 			assertTrue("2.7.1", project.isSynchronized(IResource.DEPTH_INFINITE));

 			assertClose(input);

 			assertTrue("3.5", project.isSynchronized(IResource.DEPTH_INFINITE));
 			try {
 				project.delete(IResource.FORCE, getMonitor());
 			} catch (CoreException e) {
 				fail("4.0", e);
 			}

 			assertTrue("5.1", !project.exists());
 			assertTrue("5.2", !file1.exists());
 			assertTrue("5.3", file1.isSynchronized(IResource.DEPTH_INFINITE));
 			assertTrue("5.4", project.isSynchronized(IResource.DEPTH_INFINITE));

 			assertTrue("6.0", !projectRoot.exists());
 		} finally {
 			try {
 				assertClose(input);
 			} finally {
 				if (projectRoot != null) {
 					ensureDoesNotExistInFileSystem(projectRoot);
 				}
 			}
 		}
 	}

 	/**
 	 * Tries to delete an open project containing an irremovable file.
 	 * Works only for Linux with natives.
 	 */
 	public void testDeleteOpenProjectLinux() {
 		if (!(Platform.getOS().equals(Platform.OS_LINUX) && isReadOnlySupported())) {
 			return;
 		}

 		IProject project = null;
 		File projectRoot = null;
 		IFolder folder = null;
 		try {
 			IWorkspace workspace = getWorkspace();
 			project = workspace.getRoot().getProject(getUniqueString());
 			folder = project.getFolder("a_folder");
 			IFile file1 = folder.getFile("file1.txt");
 			IFile file2 = project.getFile("file2.txt");

 			ensureExistsInWorkspace(new IResource[] {file1, file2}, true);
 			projectRoot = project.getLocation().toFile();

 			// marks folder as read-only so its files cannot be deleted on Linux
 			setReadOnly(folder, true);

 			IFile projectFile = project.getFile(".project");
 			assertTrue("1.2", projectFile.exists());
 			assertTrue("1.3", projectFile.isSynchronized(IResource.DEPTH_INFINITE));

 			try {
 				project.delete(IResource.FORCE, getMonitor());
 				fail("2.0 - should have failed");
 			} catch (CoreException ce) {
 				// success - a file couldn't be removed
 			}
 			assertTrue("2.1", project.exists());
 			assertTrue("2.2", file1.exists());
 			assertTrue("2.3", !file2.exists());
 			assertTrue("2.5", folder.exists());
 			assertTrue("2.6", projectFile.exists());
 			assertTrue("2.7", project.isSynchronized(IResource.DEPTH_INFINITE));

 			setReadOnly(folder, false);

 			assertTrue("3.5", project.isSynchronized(IResource.DEPTH_INFINITE));
 			try {
 				project.delete(IResource.FORCE, getMonitor());
 			} catch (CoreException ce) {
 				ce.printStackTrace();
 				fail("4.0", ce);
 			}

 			assertTrue("5.1", !project.exists());
 			assertTrue("5.2", !file1.exists());
 			assertTrue("5.3", file1.isSynchronized(IResource.DEPTH_INFINITE));
 			assertTrue("5.4", project.isSynchronized(IResource.DEPTH_INFINITE));

 			assertTrue("6.0", !projectRoot.exists());
 		} finally {
 			if (folder != null && folder.exists()) {
 				setReadOnly(folder, false);
 			}
 			if (projectRoot != null) {
 				ensureDoesNotExistInFileSystem(projectRoot);
 			}
 		}
 	}

 	/**
 	 * Tries to delete a closed project containing an unremovable file.
 	 * Works only for Windows.
 	 */
 	public void testDeleteClosedProjectWindows() {
 		if (!isWindows()) {
 			return;
 		}

 		IProject project = null;
 		InputStream input = null;
 		File projectRoot = null;
 		IFile file1 = null;
 		try {
 			IWorkspace workspace = getWorkspace();
 			project = workspace.getRoot().getProject(getUniqueString());
 			IFolder folder = project.getFolder("a_folder");
 			file1 = folder.getFile("file1.txt");
 			IFile file2 = project.getFile("file2.txt");
 			IFile file3 = folder.getFile("file3.txt");
 			IFile projectFile = project.getFile(new Path(".project"));

 			ensureExistsInWorkspace(new IResource[] {file1, file2, file3}, true);

 			projectRoot = project.getLocation().toFile();

 			// opens a file so it cannot be removed on Windows
 			try {
 				input = file1.getContents();
 			} catch (CoreException ce) {
 				ce.printStackTrace();
 				fail("1.0");
 			}

 			try {
 				project.close(getMonitor());
 			} catch (CoreException e) {
 				fail("1.1", e);
 			}

 			try {
 				project.delete(IResource.FORCE | IResource.ALWAYS_DELETE_PROJECT_CONTENT, getMonitor());
 				fail("2.0 - should have failed");
 			} catch (CoreException ce) {
 				// success - a file couldn't be removed
 			}
 			assertTrue("2.1", project.exists());
 			assertTrue("2.7", project.isSynchronized(IResource.DEPTH_INFINITE));
 			assertExistsInFileSystem("2.8", projectFile);

 			assertClose(input);
 			assertTrue("3.5", project.isSynchronized(IResource.DEPTH_INFINITE));
 			try {
 				project.delete(IResource.FORCE | IResource.ALWAYS_DELETE_PROJECT_CONTENT, getMonitor());
 			} catch (CoreException ce) {
 				ce.printStackTrace();
 				fail("4.0", ce);
 			}

 			assertTrue("5.1", !project.exists());
 			assertTrue("5.3", project.isSynchronized(IResource.DEPTH_INFINITE));
 			assertTrue("6.0", !projectRoot.exists());
 			assertDoesNotExistInFileSystem("7.0", projectFile);
 		} finally {
 			try {
 				if (input != null) {
 					input.close();
 				}
 			} catch (IOException e) {
 				fail("8.0", e);
 			} finally {
 				if (projectRoot != null) {
 					ensureDoesNotExistInFileSystem(projectRoot);
 				}
 			}
 		}
 	}

 	/**
 	 * Tries to delete a closed project containing an unremovable file.
 	 * Works only for Linux with natives.
 	 *
 	 * TODO: enable this test once bug 48321 is fixed.
 	 */
 	public void testDeleteClosedProjectLinux() {
 		if (!(Platform.getOS().equals(Platform.OS_LINUX))) {
 			return;
 		}

 		IProject project = null;
 		File projectRoot = null;
 		IFolder folder = null;
 		try {
 			IWorkspace workspace = getWorkspace();
 			project = workspace.getRoot().getProject(getUniqueString());
 			folder = project.getFolder("a_folder");
 			IFile file1 = folder.getFile("file1.txt");
 			IFile file2 = project.getFile("file2.txt");
 			IFile projectFile = project.getFile(new Path(".project"));

 			ensureExistsInWorkspace(new IResource[] {file1, file2}, true);

 			projectRoot = project.getLocation().toFile();

 			// marks folder as read-only so its files cannot be removed on Linux
 			setReadOnly(folder, true);

 			try {
 				project.close(getMonitor());
 			} catch (CoreException e) {
 				fail("1.0", e);
 			}

 			try {
 				project.delete(IResource.FORCE | IResource.ALWAYS_DELETE_PROJECT_CONTENT, getMonitor());
 				fail("2.0 - should have failed");
 			} catch (CoreException ce) {
 				// success - a file couldn't be removed
 			}

 			assertTrue("3.0", project.exists());
 			assertTrue("3.1", project.isSynchronized(IResource.DEPTH_INFINITE));
 			assertExistsInFileSystem("3.2", projectFile);

 			try {
 				project.open(getMonitor());
 			} catch (CoreException e) {
 				fail("4.0", e);
 			}

 			setReadOnly(folder, false);
 			try {
 				project.delete(IResource.FORCE | IResource.ALWAYS_DELETE_PROJECT_CONTENT, getMonitor());
 			} catch (CoreException ce) {
 				ce.printStackTrace();
 				fail("5.0", ce);
 			}

 			assertTrue("6.0", !project.exists());
 			assertTrue("6.1", project.isSynchronized(IResource.DEPTH_INFINITE));
 			assertTrue("6.2", !projectRoot.exists());
 			assertDoesNotExistInFileSystem("6.3", projectFile);
 		} finally {
 			if (folder != null && folder.exists()) {
 				setReadOnly(folder, false);
 			}
 			if (projectRoot != null) {
 				ensureDoesNotExistInFileSystem(projectRoot);
 			}
 		}
 	}

 	/**
 	 * Tries to delete a folder containing an unremovable file.
 	 * Works only for Windows.
 	 */
 	public void testDeleteFolderWindows() {
 		if (!isWindows()) {
 			return;
 		}

 		IProject project = null;
 		InputStream input = null;
 		File projectRoot = null;
 		try {
 			IWorkspace workspace = getWorkspace();
 			project = workspace.getRoot().getProject(getUniqueString());
 			IFolder folder = project.getFolder("a_folder");
 			IFile file1 = folder.getFile("file1.txt");
 			IFile file3 = folder.getFile("file3.txt");

 			ensureExistsInWorkspace(new IResource[] {file1, file3}, true);
 			projectRoot = project.getLocation().toFile();

 			// opens a file so it cannot be removed on Windows
 			try {
 				input = file1.getContents();
 			} catch (CoreException ce) {
 				ce.printStackTrace();
 				fail("1.0");
 			}

 			try {
 				folder.delete(IResource.FORCE, getMonitor());
 				fail("2.0 - should have failed");
 			} catch (CoreException ce) {
 				// success - a file couldn't be removed
 			}
 			assertTrue("2.2", file1.exists());
 			assertTrue("2.4", !file3.exists());
 			assertTrue("2.5", folder.exists());
 			assertTrue("2.7", folder.isSynchronized(IResource.DEPTH_INFINITE));

 			assertClose(input);

 			assertTrue("3.5", project.isSynchronized(IResource.DEPTH_INFINITE));
 			try {
 				folder.delete(IResource.FORCE, getMonitor());
 			} catch (CoreException ce) {
 				ce.printStackTrace();
 				fail("4.0", ce);
 			}
 			assertTrue("5.1", !file1.exists());
 			assertTrue("5.2", !folder.exists());
 			assertTrue("5.3", file1.isSynchronized(IResource.DEPTH_INFINITE));
 			assertTrue("5.4", folder.isSynchronized(IResource.DEPTH_INFINITE));
 		} finally {
 			try {
 				assertClose(input);
 			} finally {
 				if (projectRoot != null) {
 					ensureDoesNotExistInFileSystem(projectRoot);
 				}
 			}
 		}
 	}

 	/**
 	 * Tries to delete a folder containing an irremovable file.
 	 * Works only for Linux with natives.
 	 */
 	public void testDeleteFolderLinux() {
 		if (!(Platform.getOS().equals(Platform.OS_LINUX))) {
 			return;
 		}

 		IProject project = null;
 		File projectRoot = null;
 		IFolder subFolder = null;
 		try {
 			IWorkspace workspace = getWorkspace();
 			project = workspace.getRoot().getProject(getUniqueString());
 			IFolder folder = project.getFolder("a_folder");
 			subFolder = folder.getFolder("sub-folder");
 			IFile file1 = subFolder.getFile("file1.txt");
 			IFile file3 = folder.getFile("file3.txt");

 			ensureExistsInWorkspace(new IResource[] {file1, file3}, true);
 			projectRoot = project.getLocation().toFile();

 			// marks sub-folder as read-only so its files cannot be removed on Linux
 			setReadOnly(subFolder, true);

 			try {
 				folder.delete(IResource.FORCE, getMonitor());
 				fail("2.0 - should have failed");
 			} catch (CoreException ce) {
 				// success - a file couldn't be removed
 			}
 			assertTrue("2.2", file1.exists());
 			assertTrue("2.3", subFolder.exists());
 			assertTrue("2.4", !file3.exists());
 			assertTrue("2.5", folder.exists());
 			assertTrue("2.7", folder.isSynchronized(IResource.DEPTH_INFINITE));

 			setReadOnly(subFolder, false);

 			assertTrue("3.5", project.isSynchronized(IResource.DEPTH_INFINITE));
 			try {
 				folder.delete(IResource.FORCE, getMonitor());
 			} catch (CoreException ce) {
 				ce.printStackTrace();
 				fail("4.0", ce);
 			}
 			assertTrue("5.1", !file1.exists());
 			assertTrue("5.2", !subFolder.exists());
 			assertTrue("5.3", !folder.exists());
 			assertTrue("5.4", file1.isSynchronized(IResource.DEPTH_INFINITE));
 			assertTrue("5.5", folder.isSynchronized(IResource.DEPTH_INFINITE));
 		} finally {
 			if (subFolder != null && subFolder.exists()) {
 				setReadOnly(subFolder, false);
 			}
 			if (projectRoot != null) {
 				ensureDoesNotExistInFileSystem(projectRoot);
 			}
 		}
 	}

 	/**
 	 * @see org.eclipse.core.tests.harness.ResourceTest#tearDown()
 	 */
 	@Override
 	protected void tearDown() throws Exception {
 		super.tearDown();
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2015 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.core.tests.resources.regression;

	import java.io.*;
	import junit.framework.Test;
	import junit.framework.TestSuite;
	import org.eclipse.core.resources.*;
	import org.eclipse.core.runtime.*;
	import org.eclipse.core.tests.resources.ResourceTest;

	/**
	* A parent container (projects and folders) would become out-of-sync if any of
	* its children could not be deleted for some reason. These platform-
	* specific test cases ensure that it does not happen.
	*/
	public class Bug_026294 extends ResourceTest {

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

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

	/**
	* Tries to delete an open project containing an unremovable file.
	* Works only for Windows.
	*/
	public void testDeleteOpenProjectWindows() {
	if (!(isWindows())) {
	return;
	}

	IProject project = null;
	InputStream input = null;
	File projectRoot = null;
	try {
	IWorkspace workspace = getWorkspace();
	project = workspace.getRoot().getProject(getUniqueString());
	IFolder folder = project.getFolder("a_folder");
	IFile file1 = folder.getFile("file1.txt");
	IFile file2 = project.getFile("file2.txt");
	IFile file3 = folder.getFile("file3.txt");
	IFile projectFile = project.getFile(new Path(".project"));

	ensureExistsInWorkspace(new IResource[] {file1, file2, file3}, true);
	projectRoot = project.getLocation().toFile();

	assertExistsInFileSystem("0.0", file1);
	assertExistsInFileSystem("0.1", file2);
	assertExistsInFileSystem("0.2", file3);
	assertExistsInFileSystem("0.3", folder);
	assertExistsInFileSystem("0.4", projectFile);

	// opens a file so it cannot be removed on Windows
	try {
	input = file1.getContents();
	} catch (CoreException ce) {
	ce.printStackTrace();
	fail("1.0");
	}
	assertTrue("1.2", projectFile.exists());
	assertTrue("1.3", projectFile.isSynchronized(IResource.DEPTH_INFINITE));

	try {
	project.delete(IResource.FORCE, getMonitor());
	fail("2.0 - should have failed");
	} catch (CoreException ce) {
	// success - a file couldn't be removed
	}

	// Delete is best-case so check all the files.
	// Do a check on disk and in the workspace in case something is out of sync.
	assertExistsInWorkspace("2.1.1", project);
	assertExistsInFileSystem("2.1.2", project);

	assertExistsInWorkspace("2.2.1", file1);
	assertExistsInFileSystem("2.2.2", file1);
	assertTrue("2.2.3", file1.isSynchronized(IResource.DEPTH_INFINITE));

	assertDoesNotExistInWorkspace("2.3.1", file2);
	assertDoesNotExistInFileSystem("2.3.2", file2);
	assertTrue("2.3.3", file2.isSynchronized(IResource.DEPTH_INFINITE));

	assertDoesNotExistInWorkspace("2.4.1", file3);
	assertDoesNotExistInFileSystem("2.4.2", file3);
	assertTrue("2.4.3", file3.isSynchronized(IResource.DEPTH_INFINITE));

	assertExistsInWorkspace("2.5.1", folder);
	assertExistsInFileSystem("2.5.2", folder);
	assertTrue("2.5.3", folder.isSynchronized(IResource.DEPTH_INFINITE));

	assertExistsInWorkspace("2.6.1", projectFile);
	assertExistsInFileSystem("2.6.2", projectFile);
	assertTrue("2.6.3", projectFile.isSynchronized(IResource.DEPTH_INFINITE));

	assertTrue("2.7.0", project.isSynchronized(IResource.DEPTH_ZERO));
	assertTrue("2.7.1", project.isSynchronized(IResource.DEPTH_INFINITE));

	assertClose(input);

	assertTrue("3.5", project.isSynchronized(IResource.DEPTH_INFINITE));
	try {
	project.delete(IResource.FORCE, getMonitor());
	} catch (CoreException e) {
	fail("4.0", e);
	}

	assertTrue("5.1", !project.exists());
	assertTrue("5.2", !file1.exists());
	assertTrue("5.3", file1.isSynchronized(IResource.DEPTH_INFINITE));
	assertTrue("5.4", project.isSynchronized(IResource.DEPTH_INFINITE));

	assertTrue("6.0", !projectRoot.exists());
	} finally {
	try {
	assertClose(input);
	} finally {
	if (projectRoot != null) {
	ensureDoesNotExistInFileSystem(projectRoot);
	}
	}
	}
	}

	/**
	* Tries to delete an open project containing an irremovable file.
	* Works only for Linux with natives.
	*/
	public void testDeleteOpenProjectLinux() {
	if (!(Platform.getOS().equals(Platform.OS_LINUX) && isReadOnlySupported())) {
	return;
	}

	IProject project = null;
	File projectRoot = null;
	IFolder folder = null;
	try {
	IWorkspace workspace = getWorkspace();
	project = workspace.getRoot().getProject(getUniqueString());
	folder = project.getFolder("a_folder");
	IFile file1 = folder.getFile("file1.txt");
	IFile file2 = project.getFile("file2.txt");

	ensureExistsInWorkspace(new IResource[] {file1, file2}, true);
	projectRoot = project.getLocation().toFile();

	// marks folder as read-only so its files cannot be deleted on Linux
	setReadOnly(folder, true);

	IFile projectFile = project.getFile(".project");
	assertTrue("1.2", projectFile.exists());
	assertTrue("1.3", projectFile.isSynchronized(IResource.DEPTH_INFINITE));

	try {
	project.delete(IResource.FORCE, getMonitor());
	fail("2.0 - should have failed");
	} catch (CoreException ce) {
	// success - a file couldn't be removed
	}
	assertTrue("2.1", project.exists());
	assertTrue("2.2", file1.exists());
	assertTrue("2.3", !file2.exists());
	assertTrue("2.5", folder.exists());
	assertTrue("2.6", projectFile.exists());
	assertTrue("2.7", project.isSynchronized(IResource.DEPTH_INFINITE));

	setReadOnly(folder, false);

	assertTrue("3.5", project.isSynchronized(IResource.DEPTH_INFINITE));
	try {
	project.delete(IResource.FORCE, getMonitor());
	} catch (CoreException ce) {
	ce.printStackTrace();
	fail("4.0", ce);
	}

	assertTrue("5.1", !project.exists());
	assertTrue("5.2", !file1.exists());
	assertTrue("5.3", file1.isSynchronized(IResource.DEPTH_INFINITE));
	assertTrue("5.4", project.isSynchronized(IResource.DEPTH_INFINITE));

	assertTrue("6.0", !projectRoot.exists());
	} finally {
	if (folder != null && folder.exists()) {
	setReadOnly(folder, false);
	}
	if (projectRoot != null) {
	ensureDoesNotExistInFileSystem(projectRoot);
	}
	}
	}

	/**
	* Tries to delete a closed project containing an unremovable file.
	* Works only for Windows.
	*/
	public void testDeleteClosedProjectWindows() {
	if (!isWindows()) {
	return;
	}

	IProject project = null;
	InputStream input = null;
	File projectRoot = null;
	IFile file1 = null;
	try {
	IWorkspace workspace = getWorkspace();
	project = workspace.getRoot().getProject(getUniqueString());
	IFolder folder = project.getFolder("a_folder");
	file1 = folder.getFile("file1.txt");
	IFile file2 = project.getFile("file2.txt");
	IFile file3 = folder.getFile("file3.txt");
	IFile projectFile = project.getFile(new Path(".project"));

	ensureExistsInWorkspace(new IResource[] {file1, file2, file3}, true);

	projectRoot = project.getLocation().toFile();

	// opens a file so it cannot be removed on Windows
	try {
	input = file1.getContents();
	} catch (CoreException ce) {
	ce.printStackTrace();
	fail("1.0");
	}

	try {
	project.close(getMonitor());
	} catch (CoreException e) {
	fail("1.1", e);
	}

	try {
	project.delete(IResource.FORCE \| IResource.ALWAYS_DELETE_PROJECT_CONTENT, getMonitor());
	fail("2.0 - should have failed");
	} catch (CoreException ce) {
	// success - a file couldn't be removed
	}
	assertTrue("2.1", project.exists());
	assertTrue("2.7", project.isSynchronized(IResource.DEPTH_INFINITE));
	assertExistsInFileSystem("2.8", projectFile);

	assertClose(input);
	assertTrue("3.5", project.isSynchronized(IResource.DEPTH_INFINITE));
	try {
	project.delete(IResource.FORCE \| IResource.ALWAYS_DELETE_PROJECT_CONTENT, getMonitor());
	} catch (CoreException ce) {
	ce.printStackTrace();
	fail("4.0", ce);
	}

	assertTrue("5.1", !project.exists());
	assertTrue("5.3", project.isSynchronized(IResource.DEPTH_INFINITE));
	assertTrue("6.0", !projectRoot.exists());
	assertDoesNotExistInFileSystem("7.0", projectFile);
	} finally {
	try {
	if (input != null) {
	input.close();
	}
	} catch (IOException e) {
	fail("8.0", e);
	} finally {
	if (projectRoot != null) {
	ensureDoesNotExistInFileSystem(projectRoot);
	}
	}
	}
	}

	/**
	* Tries to delete a closed project containing an unremovable file.
	* Works only for Linux with natives.
	*
	* TODO: enable this test once bug 48321 is fixed.
	*/
	public void testDeleteClosedProjectLinux() {
	if (!(Platform.getOS().equals(Platform.OS_LINUX))) {
	return;
	}

	IProject project = null;
	File projectRoot = null;
	IFolder folder = null;
	try {
	IWorkspace workspace = getWorkspace();
	project = workspace.getRoot().getProject(getUniqueString());
	folder = project.getFolder("a_folder");
	IFile file1 = folder.getFile("file1.txt");
	IFile file2 = project.getFile("file2.txt");
	IFile projectFile = project.getFile(new Path(".project"));

	ensureExistsInWorkspace(new IResource[] {file1, file2}, true);

	projectRoot = project.getLocation().toFile();

	// marks folder as read-only so its files cannot be removed on Linux
	setReadOnly(folder, true);

	try {
	project.close(getMonitor());
	} catch (CoreException e) {
	fail("1.0", e);
	}

	try {
	project.delete(IResource.FORCE \| IResource.ALWAYS_DELETE_PROJECT_CONTENT, getMonitor());
	fail("2.0 - should have failed");
	} catch (CoreException ce) {
	// success - a file couldn't be removed
	}

	assertTrue("3.0", project.exists());
	assertTrue("3.1", project.isSynchronized(IResource.DEPTH_INFINITE));
	assertExistsInFileSystem("3.2", projectFile);

	try {
	project.open(getMonitor());
	} catch (CoreException e) {
	fail("4.0", e);
	}

	setReadOnly(folder, false);
	try {
	project.delete(IResource.FORCE \| IResource.ALWAYS_DELETE_PROJECT_CONTENT, getMonitor());
	} catch (CoreException ce) {
	ce.printStackTrace();
	fail("5.0", ce);
	}

	assertTrue("6.0", !project.exists());
	assertTrue("6.1", project.isSynchronized(IResource.DEPTH_INFINITE));
	assertTrue("6.2", !projectRoot.exists());
	assertDoesNotExistInFileSystem("6.3", projectFile);
	} finally {
	if (folder != null && folder.exists()) {
	setReadOnly(folder, false);
	}
	if (projectRoot != null) {
	ensureDoesNotExistInFileSystem(projectRoot);
	}
	}
	}

	/**
	* Tries to delete a folder containing an unremovable file.
	* Works only for Windows.
	*/
	public void testDeleteFolderWindows() {
	if (!isWindows()) {
	return;
	}

	IProject project = null;
	InputStream input = null;
	File projectRoot = null;
	try {
	IWorkspace workspace = getWorkspace();
	project = workspace.getRoot().getProject(getUniqueString());
	IFolder folder = project.getFolder("a_folder");
	IFile file1 = folder.getFile("file1.txt");
	IFile file3 = folder.getFile("file3.txt");

	ensureExistsInWorkspace(new IResource[] {file1, file3}, true);
	projectRoot = project.getLocation().toFile();

	// opens a file so it cannot be removed on Windows
	try {
	input = file1.getContents();
	} catch (CoreException ce) {
	ce.printStackTrace();
	fail("1.0");
	}

	try {
	folder.delete(IResource.FORCE, getMonitor());
	fail("2.0 - should have failed");
	} catch (CoreException ce) {
	// success - a file couldn't be removed
	}
	assertTrue("2.2", file1.exists());
	assertTrue("2.4", !file3.exists());
	assertTrue("2.5", folder.exists());
	assertTrue("2.7", folder.isSynchronized(IResource.DEPTH_INFINITE));

	assertClose(input);

	assertTrue("3.5", project.isSynchronized(IResource.DEPTH_INFINITE));
	try {
	folder.delete(IResource.FORCE, getMonitor());
	} catch (CoreException ce) {
	ce.printStackTrace();
	fail("4.0", ce);
	}
	assertTrue("5.1", !file1.exists());
	assertTrue("5.2", !folder.exists());
	assertTrue("5.3", file1.isSynchronized(IResource.DEPTH_INFINITE));
	assertTrue("5.4", folder.isSynchronized(IResource.DEPTH_INFINITE));
	} finally {
	try {
	assertClose(input);
	} finally {
	if (projectRoot != null) {
	ensureDoesNotExistInFileSystem(projectRoot);
	}
	}
	}
	}

	/**
	* Tries to delete a folder containing an irremovable file.
	* Works only for Linux with natives.
	*/
	public void testDeleteFolderLinux() {
	if (!(Platform.getOS().equals(Platform.OS_LINUX))) {
	return;
	}

	IProject project = null;
	File projectRoot = null;
	IFolder subFolder = null;
	try {
	IWorkspace workspace = getWorkspace();
	project = workspace.getRoot().getProject(getUniqueString());
	IFolder folder = project.getFolder("a_folder");
	subFolder = folder.getFolder("sub-folder");
	IFile file1 = subFolder.getFile("file1.txt");
	IFile file3 = folder.getFile("file3.txt");

	ensureExistsInWorkspace(new IResource[] {file1, file3}, true);
	projectRoot = project.getLocation().toFile();

	// marks sub-folder as read-only so its files cannot be removed on Linux
	setReadOnly(subFolder, true);

	try {
	folder.delete(IResource.FORCE, getMonitor());
	fail("2.0 - should have failed");
	} catch (CoreException ce) {
	// success - a file couldn't be removed
	}
	assertTrue("2.2", file1.exists());
	assertTrue("2.3", subFolder.exists());
	assertTrue("2.4", !file3.exists());
	assertTrue("2.5", folder.exists());
	assertTrue("2.7", folder.isSynchronized(IResource.DEPTH_INFINITE));

	setReadOnly(subFolder, false);

	assertTrue("3.5", project.isSynchronized(IResource.DEPTH_INFINITE));
	try {
	folder.delete(IResource.FORCE, getMonitor());
	} catch (CoreException ce) {
	ce.printStackTrace();
	fail("4.0", ce);
	}
	assertTrue("5.1", !file1.exists());
	assertTrue("5.2", !subFolder.exists());
	assertTrue("5.3", !folder.exists());
	assertTrue("5.4", file1.isSynchronized(IResource.DEPTH_INFINITE));
	assertTrue("5.5", folder.isSynchronized(IResource.DEPTH_INFINITE));
	} finally {
	if (subFolder != null && subFolder.exists()) {
	setReadOnly(subFolder, false);
	}
	if (projectRoot != null) {
	ensureDoesNotExistInFileSystem(projectRoot);
	}
	}
	}

	/**
	* @see org.eclipse.core.tests.harness.ResourceTest#tearDown()
	*/
	@Override
	protected void tearDown() throws Exception {
	super.tearDown();
	}
	}