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

 /*******************************************************************************
  * Copyright (c) 2000, 2017 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
  *     Sergey Prigogin (Google) - testWorkingLocationDeletion_bug433061
  *     Sergey Prigogin (Google) - [440283] Modify symlink tests to run on Windows with or without administrator privileges
  *******************************************************************************/
 package org.eclipse.core.tests.resources;

 import java.io.File;
 import java.io.InputStream;
 import junit.framework.Test;
 import junit.framework.TestSuite;
 import org.eclipse.core.internal.resources.Workspace;
 import org.eclipse.core.resources.*;
 import org.eclipse.core.runtime.*;

 /**
  * This class should be refactored into the black box tests for
  * solution, project, folder and file.
  */
 public class WorkspaceTest extends ResourceTest {
 	/**
 	 * Need a zero argument constructor to satisfy the test harness.
 	 * This constructor should not do any real work nor should it be
 	 * called by user code.
 	 */
 	public WorkspaceTest() {
 		super();
 	}

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

 	/**
 	 * All of the WorkspaceTests build on each other. This test must
 	 * be run last of all to clean up from all previous tests in this class.
 	 * @throws Exception
 	 */
 	public void doCleanup() throws Exception {
 		IPath location = getWorkspace().getRoot().getLocation().append("testProject");
 		deleteOnTearDown(location);
 		IPath location2 = getWorkspace().getRoot().getLocation().append("testProject2");
 		deleteOnTearDown(location2);
 		cleanup();
 		assertTrue(location.toOSString() + " has not been deleted", !location.toFile().exists());
 		assertTrue(location2.toOSString() + " has not been deleted", !location2.toFile().exists());
 	}

 	/**
 	 * Returns a collection of string paths describing the standard
 	 * resource hierarchy for this test.  In the string forms, folders are
 	 * represented as having trailing separators ('/').  All other resources
 	 * are files.  It is generally assumed that this hierarchy will be
 	 * inserted under some solution and project structure.
 	 */
 	@Override
 	public String[] defineHierarchy() {
 		return new String[] {"/", "/1/", "/1/1", "/1/2", "/1/3", "/2/", "/2/1", "/2/2", "/2/3", "/3/", "/3/1", "/3/2", "/3/3", "/4/", "/5"};
 	}

 	protected IProject getTestProject() {
 		return getWorkspace().getRoot().getProject("testProject");
 	}

 	protected IProject getTestProject2() {
 		return getWorkspace().getRoot().getProject("testProject2");
 	}

 	public void setGetPersistentProperty(IResource target) throws Throwable {
 		String value = "this is a test property value";
 		QualifiedName name = new QualifiedName("itp-test", "testProperty");
 		target.setPersistentProperty(name, value);
 		// see if we can get the property
 		assertTrue("get not equal set", target.getPersistentProperty(name).equals(value));
 		// see what happens if we get a non-existant property
 		name = new QualifiedName("itp-test", "testNonProperty");
 		assertNull("non-existant persistent property not missing", target.getPersistentProperty(name));
 	}

 	public static Test suite() {
 		TestSuite suite = new TestSuite(WorkspaceTest.class.getName());
 		// test the basic create operations
 		suite.addTest(new WorkspaceTest("testProjectCreation"));
 		suite.addTest(new WorkspaceTest("testFolderCreation"));
 		suite.addTest(new WorkspaceTest("testFileCreation"));
 		suite.addTest(new WorkspaceTest("testFileInFolderCreation"));
 		suite.addTest(new WorkspaceTest("testSetContents"));
 		suite.addTest(new WorkspaceTest("testFileOverFolder"));
 		suite.addTest(new WorkspaceTest("testFolderOverFile"));
 		suite.addTest(new WorkspaceTest("testProjectCreateOpenCloseDelete"));
 		suite.addTest(new WorkspaceTest("testProjectReferences"));

 		// test closing and reopening
 		suite.addTest(new WorkspaceTest("testProjectCloseOpen"));

 		// test persistent properties on all the different resource types.
 		suite.addTest(new WorkspaceTest("testSetGetProjectPersistentProperty"));
 		suite.addTest(new WorkspaceTest("testSetGetFolderPersistentProperty"));
 		suite.addTest(new WorkspaceTest("testSetGetFilePersistentProperty"));

 		// test moves
 		suite.addTest(new WorkspaceTest("testSimpleMove"));
 		suite.addTest(new WorkspaceTest("testFileMove"));
 		suite.addTest(new WorkspaceTest("testLeafFolderMove"));
 		suite.addTest(new WorkspaceTest("testFolderMove"));

 		// create a bunch of things at once
 		suite.addTest(new WorkspaceTest("testMultiCreation"));

 		// test deletions
 		suite.addTest(new WorkspaceTest("testFolderDeletion"));
 		suite.addTest(new WorkspaceTest("testFileDeletion"));
 		suite.addTest(new WorkspaceTest("testFileEmptyDeletion"));
 		suite.addTest(new WorkspaceTest("testMultiDeletion"));
 		suite.addTest(new WorkspaceTest("testProjectDeletion"));
 		suite.addTest(new WorkspaceTest("testWorkingLocationDeletion_bug433061"));

 		suite.addTest(new WorkspaceTest("doCleanup"));
 		return suite;
 	}

 	@Override
 	protected void tearDown() throws Exception {
 		// overwrite the superclass and do nothing since our test methods build on each other
 	}

 	public void testFileCreation() throws Throwable {
 		IPath path = new Path("/testProject/testFile");
 		IFile target = getWorkspace().getRoot().getFile(path);
 		target.create(null, true, getMonitor());
 		assertTrue(target.exists());
 	}

 	public void testFileDeletion() throws Throwable {
 		IPath path = new Path("/testProject/testFileForDelete");
 		IFile target = getWorkspace().getRoot().getFile(path);
 		target.create(null, true, getMonitor());
 		assertTrue(target.exists());
 		target.delete(true, getMonitor());
 		assertTrue(!target.exists());
 	}

 	public void testFileEmptyDeletion() throws Throwable {
 		IPath path = new Path("/testProject/testFileForDelete2");
 		IFile target = getWorkspace().getRoot().getFile(path);
 		target.create(getContents(""), true, getMonitor());
 		assertTrue(target.exists());
 		target.delete(true, getMonitor());
 		assertTrue(!target.exists());
 	}

 	public void testFileInFolderCreation() throws Throwable {
 		IPath path = new Path("/testProject/testFolder/testFile2");
 		IFile target = getWorkspace().getRoot().getFile(path);
 		target.create(getRandomContents(), true, getMonitor());
 		assertTrue(target.exists());
 	}

 	public void testFileMove() throws Throwable {
 		IPath path = new Path("/testProject/targetFile");
 		IFile target = getWorkspace().getRoot().getFile(path);
 		target.create(getRandomContents(), true, getMonitor());
 		IFile destination = getWorkspace().getRoot().getFile(new Path("/testProject/movedFile"));
 		target.move(destination.getFullPath(), true, getMonitor());
 		assertTrue(destination.exists());
 		assertTrue(!target.exists());
 	}

 	public void testFileOverFolder() throws Throwable {
 		IPath path = new Path("/testProject/testFolder");
 		IFolder existing = getWorkspace().getRoot().getFolder(path);
 		assertTrue(existing.exists());
 		IFile target = getWorkspace().getRoot().getFile(path);
 		try {
 			target.create(null, true, getMonitor());
 		} catch (CoreException e) {
 			assertTrue(existing.exists());
 			return;
 		}
 		fail("Should not be able to create file over folder");
 	}

 	public void testFolderCreation() throws Throwable {
 		IPath path = new Path("/testProject/testFolder");
 		IFolder target = getWorkspace().getRoot().getFolder(path);
 		target.create(true, true, getMonitor());
 		assertTrue(target.exists());
 	}

 	public void testFolderDeletion() throws Throwable {
 		IProject project = getTestProject();
 		IResource[] before = buildResources(project, new String[] {"c/", "c/b/", "c/x", "c/b/y", "c/b/z"});
 		ensureExistsInWorkspace(before, true);
 		//
 		assertExistsInWorkspace(before);
 		project.getFolder("c").delete(true, getMonitor());
 		assertDoesNotExistInWorkspace(before);
 	}

 	public void testFolderMove() throws Throwable {
 		IProject project = getTestProject();
 		IResource[] before = buildResources(project, new String[] {"b/", "b/b/", "b/x", "b/b/y", "b/b/z"});
 		IResource[] after = buildResources(project, new String[] {"a/", "a/b/", "a/x", "a/b/y", "a/b/z"});

 		// create the resources and set some content in a file that will be moved.
 		ensureExistsInWorkspace(before, true);
 		String content = getRandomString();
 		IFile file = project.getFile(new Path("b/b/z"));
 		file.setContents(getContents(content), true, false, getMonitor());

 		// Be sure the resources exist and then move them.
 		assertExistsInWorkspace(before);
 		project.getFolder("b").move(project.getFullPath().append("a"), true, getMonitor());

 		//
 		assertDoesNotExistInWorkspace(before);
 		assertExistsInWorkspace(after);
 		file = project.getFile(new Path("a/b/z"));
 		assertTrue("get not equal set", compareContent(getContents(content), file.getContents(false)));
 	}

 	public void testFolderOverFile() throws Throwable {
 		IPath path = new Path("/testProject/testFile");
 		IFile existing = getWorkspace().getRoot().getFile(path);
 		assertTrue(existing.exists());
 		IFolder target = getWorkspace().getRoot().getFolder(path);
 		try {
 			target.create(true, true, getMonitor());
 		} catch (CoreException e) {
 			assertTrue(existing.exists());
 			return;
 		}
 		fail("Should not be able to create folder over a file");
 	}

 	public void testLeafFolderMove() throws Throwable {
 		IProject project = getTestProject();
 		IFolder source = project.getFolder("testFolder");
 		IFolder dest = project.getFolder("movedFolder");
 		//
 		source.move(dest.getFullPath(), true, getMonitor());
 		assertExistsInWorkspace(dest);
 		assertDoesNotExistInWorkspace(source);
 	}

 	public void testMultiCreation() throws Throwable {
 		final IProject project = getWorkspace().getRoot().getProject("bar");
 		final IResource[] resources = buildResources(project, new String[] {"a/", "a/b"});
 		IWorkspaceRunnable body = monitor -> {
 			if (!project.exists()) {
 				project.create(null);
 			}
 			if (!project.isOpen()) {
 				project.open(null);
 			}
 			// define an operation which will create a bunch of resources including a project.
 			for (IResource resource : resources) {
 				switch (resource.getType()) {
 					case IResource.FILE :
 						((IFile) resource).create(null, false, getMonitor());
 						break;
 					case IResource.FOLDER :
 						((IFolder) resource).create(false, true, getMonitor());
 						break;
 					case IResource.PROJECT :
 						((IProject) resource).create(getMonitor());
 						break;
 				}
 			}
 		};
 		getWorkspace().run(body, getMonitor());
 		assertExistsInWorkspace(project);
 		assertExistsInWorkspace(resources);
 	}

 	public void testMultiDeletion() throws Throwable {
 		IProject project = getTestProject();
 		IResource[] before = buildResources(project, new String[] {"c/", "c/b/", "c/x", "c/b/y", "c/b/z"});
 		ensureExistsInWorkspace(before, true);
 		//
 		assertExistsInWorkspace(before);
 		getWorkspace().delete(before, true, getMonitor());
 		assertDoesNotExistInWorkspace(before);
 	}

 	public void testProjectCloseOpen() throws Throwable {
 		IProject target = getTestProject();
 		target.close(getMonitor());
 		assertTrue(target.exists());
 		assertTrue(!target.isOpen());
 		assertTrue(!target.getFolder("testFolder").exists());
 		target.open(getMonitor());
 		assertTrue(target.isOpen());
 		assertTrue(target.getFolder("testFolder").exists());
 	}

 	public void testProjectCreateOpenCloseDelete() throws Throwable {
 		IProject target = getTestProject2();
 		target.create(null, getMonitor());
 		assertTrue(target.exists());
 		target.open(getMonitor());
 		assertTrue(target.isOpen());
 		target.close(getMonitor());
 		assertTrue(!target.isOpen());
 		target.delete(true, getMonitor());
 		assertTrue(!target.exists());
 	}

 	public void testProjectCreation() throws Throwable {
 		IProject target = getTestProject();
 		target.create(null, getMonitor());
 		assertTrue(target.exists());
 		target.open(getMonitor());
 		assertTrue(target.isOpen());
 	}

 	public void testProjectDeletion() throws Throwable {
 		IProject target = getTestProject();
 		target.delete(true, getMonitor());
 		assertTrue("Project Deletion failed", !target.exists());
 	}

 	public void testWorkingLocationDeletion_bug433061() throws Throwable {
 		// Only activate this test if testing of symbolic links is possible.
 		if (!canCreateSymLinks()) {
 			return;
 		}
 		IProject project = getTestProject();
 		project.create(null, getMonitor());
 		IPath workingLocation = project.getWorkingLocation("org.eclipse.core.tests.resources");
 		IPath linkTarget = getRandomLocation();
 		try {
 			linkTarget.toFile().mkdirs();
 			File file = linkTarget.append("aFile").toFile();
 			assertTrue(file.createNewFile());
 			assertTrue(file.exists());
 			// Create a symlink in the working location of the project pointing to linkTarget.
 			createSymLink(workingLocation.toFile(), "link", linkTarget.toOSString(), true);
 			project.delete(true, getMonitor());
 			assertTrue("Project deletion failed", !project.exists());
 			assertTrue("Working location was not deleted", !workingLocation.toFile().exists());
 			assertTrue("File inside a symlinked directory got deleted", file.exists());
 		} finally {
 			Workspace.clear(linkTarget.toFile());
 		}
 	}

 	public void testProjectReferences() throws Throwable {
 		IProject target = getTestProject2();
 		target.create(null, getMonitor());
 		assertTrue(target.exists());
 		IProject project = getTestProject();
 		IProjectDescription description = project.getDescription();
 		description.setReferencedProjects(new IProject[] {target});
 		project.setDescription(description, getMonitor());
 		assertTrue(target.getReferencingProjects().length == 1);

 		target.delete(true, getMonitor());
 		assertTrue(!target.exists());
 	}

 	public void testSetContents() throws Throwable {
 		IPath path = new Path("/testProject/testFile");
 		IFile target = getWorkspace().getRoot().getFile(path);
 		String testString = getRandomString();
 		target.setContents(getContents(testString), true, false, getMonitor());
 		InputStream content = null;
 		try {
 			content = target.getContents(false);
 			assertTrue("get not equal set", compareContent(content, getContents(testString)));
 		} finally {
 			content.close();
 		}
 	}

 	public void testSetGetFilePersistentProperty() throws Throwable {
 		IResource target = getWorkspace().getRoot().getFile(new Path("/testProject/testFile"));
 		setGetPersistentProperty(target);
 	}

 	public void testSetGetFolderPersistentProperty() throws Throwable {
 		IResource target = getWorkspace().getRoot().getFolder(new Path("/testProject/testFolder"));
 		setGetPersistentProperty(target);
 	}

 	public void testSetGetProjectPersistentProperty() throws Throwable {
 		IResource target = getWorkspace().getRoot().getProject("/testProject");
 		setGetPersistentProperty(target);
 	}

 	public void testSetProperty() throws Throwable {
 		IPath path = new Path("/testProject/testFile");
 		IFile target = getWorkspace().getRoot().getFile(path);
 		String value = "this is a test property value";
 		QualifiedName name = new QualifiedName("itp-test", "testProperty");
 		target.setPersistentProperty(name, value);
 		assertTrue("get not equal set", target.getPersistentProperty(name).equals(value));
 	}

 	public void testSimpleMove() throws Throwable {
 		IPath path = new Path("/testProject/simpleFile");
 		IFile target = getWorkspace().getRoot().getFile(path);
 		target.create(getRandomContents(), true, getMonitor());
 		IFile destination = getWorkspace().getRoot().getFile(new Path("/testProject/newSimpleFile"));
 		target.move(destination.getFullPath(), true, getMonitor());
 		assertTrue(destination.exists());
 		assertTrue(!target.exists());
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2017 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
	* Sergey Prigogin (Google) - testWorkingLocationDeletion_bug433061
	* Sergey Prigogin (Google) - [440283] Modify symlink tests to run on Windows with or without administrator privileges
	*******************************************************************************/
	package org.eclipse.core.tests.resources;

	import java.io.File;
	import java.io.InputStream;
	import junit.framework.Test;
	import junit.framework.TestSuite;
	import org.eclipse.core.internal.resources.Workspace;
	import org.eclipse.core.resources.*;
	import org.eclipse.core.runtime.*;

	/**
	* This class should be refactored into the black box tests for
	* solution, project, folder and file.
	*/
	public class WorkspaceTest extends ResourceTest {
	/**
	* Need a zero argument constructor to satisfy the test harness.
	* This constructor should not do any real work nor should it be
	* called by user code.
	*/
	public WorkspaceTest() {
	super();
	}

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

	/**
	* All of the WorkspaceTests build on each other. This test must
	* be run last of all to clean up from all previous tests in this class.
	* @throws Exception
	*/
	public void doCleanup() throws Exception {
	IPath location = getWorkspace().getRoot().getLocation().append("testProject");
	deleteOnTearDown(location);
	IPath location2 = getWorkspace().getRoot().getLocation().append("testProject2");
	deleteOnTearDown(location2);
	cleanup();
	assertTrue(location.toOSString() + " has not been deleted", !location.toFile().exists());
	assertTrue(location2.toOSString() + " has not been deleted", !location2.toFile().exists());
	}

	/**
	* Returns a collection of string paths describing the standard
	* resource hierarchy for this test. In the string forms, folders are
	* represented as having trailing separators ('/'). All other resources
	* are files. It is generally assumed that this hierarchy will be
	* inserted under some solution and project structure.
	*/
	@Override
	public String[] defineHierarchy() {
	return new String[] {"/", "/1/", "/1/1", "/1/2", "/1/3", "/2/", "/2/1", "/2/2", "/2/3", "/3/", "/3/1", "/3/2", "/3/3", "/4/", "/5"};
	}

	protected IProject getTestProject() {
	return getWorkspace().getRoot().getProject("testProject");
	}

	protected IProject getTestProject2() {
	return getWorkspace().getRoot().getProject("testProject2");
	}

	public void setGetPersistentProperty(IResource target) throws Throwable {
	String value = "this is a test property value";
	QualifiedName name = new QualifiedName("itp-test", "testProperty");
	target.setPersistentProperty(name, value);
	// see if we can get the property
	assertTrue("get not equal set", target.getPersistentProperty(name).equals(value));
	// see what happens if we get a non-existant property
	name = new QualifiedName("itp-test", "testNonProperty");
	assertNull("non-existant persistent property not missing", target.getPersistentProperty(name));
	}

	public static Test suite() {
	TestSuite suite = new TestSuite(WorkspaceTest.class.getName());
	// test the basic create operations
	suite.addTest(new WorkspaceTest("testProjectCreation"));
	suite.addTest(new WorkspaceTest("testFolderCreation"));
	suite.addTest(new WorkspaceTest("testFileCreation"));
	suite.addTest(new WorkspaceTest("testFileInFolderCreation"));
	suite.addTest(new WorkspaceTest("testSetContents"));
	suite.addTest(new WorkspaceTest("testFileOverFolder"));
	suite.addTest(new WorkspaceTest("testFolderOverFile"));
	suite.addTest(new WorkspaceTest("testProjectCreateOpenCloseDelete"));
	suite.addTest(new WorkspaceTest("testProjectReferences"));

	// test closing and reopening
	suite.addTest(new WorkspaceTest("testProjectCloseOpen"));

	// test persistent properties on all the different resource types.
	suite.addTest(new WorkspaceTest("testSetGetProjectPersistentProperty"));
	suite.addTest(new WorkspaceTest("testSetGetFolderPersistentProperty"));
	suite.addTest(new WorkspaceTest("testSetGetFilePersistentProperty"));

	// test moves
	suite.addTest(new WorkspaceTest("testSimpleMove"));
	suite.addTest(new WorkspaceTest("testFileMove"));
	suite.addTest(new WorkspaceTest("testLeafFolderMove"));
	suite.addTest(new WorkspaceTest("testFolderMove"));

	// create a bunch of things at once
	suite.addTest(new WorkspaceTest("testMultiCreation"));

	// test deletions
	suite.addTest(new WorkspaceTest("testFolderDeletion"));
	suite.addTest(new WorkspaceTest("testFileDeletion"));
	suite.addTest(new WorkspaceTest("testFileEmptyDeletion"));
	suite.addTest(new WorkspaceTest("testMultiDeletion"));
	suite.addTest(new WorkspaceTest("testProjectDeletion"));
	suite.addTest(new WorkspaceTest("testWorkingLocationDeletion_bug433061"));

	suite.addTest(new WorkspaceTest("doCleanup"));
	return suite;
	}

	@Override
	protected void tearDown() throws Exception {
	// overwrite the superclass and do nothing since our test methods build on each other
	}

	public void testFileCreation() throws Throwable {
	IPath path = new Path("/testProject/testFile");
	IFile target = getWorkspace().getRoot().getFile(path);
	target.create(null, true, getMonitor());
	assertTrue(target.exists());
	}

	public void testFileDeletion() throws Throwable {
	IPath path = new Path("/testProject/testFileForDelete");
	IFile target = getWorkspace().getRoot().getFile(path);
	target.create(null, true, getMonitor());
	assertTrue(target.exists());
	target.delete(true, getMonitor());
	assertTrue(!target.exists());
	}

	public void testFileEmptyDeletion() throws Throwable {
	IPath path = new Path("/testProject/testFileForDelete2");
	IFile target = getWorkspace().getRoot().getFile(path);
	target.create(getContents(""), true, getMonitor());
	assertTrue(target.exists());
	target.delete(true, getMonitor());
	assertTrue(!target.exists());
	}

	public void testFileInFolderCreation() throws Throwable {
	IPath path = new Path("/testProject/testFolder/testFile2");
	IFile target = getWorkspace().getRoot().getFile(path);
	target.create(getRandomContents(), true, getMonitor());
	assertTrue(target.exists());
	}

	public void testFileMove() throws Throwable {
	IPath path = new Path("/testProject/targetFile");
	IFile target = getWorkspace().getRoot().getFile(path);
	target.create(getRandomContents(), true, getMonitor());
	IFile destination = getWorkspace().getRoot().getFile(new Path("/testProject/movedFile"));
	target.move(destination.getFullPath(), true, getMonitor());
	assertTrue(destination.exists());
	assertTrue(!target.exists());
	}

	public void testFileOverFolder() throws Throwable {
	IPath path = new Path("/testProject/testFolder");
	IFolder existing = getWorkspace().getRoot().getFolder(path);
	assertTrue(existing.exists());
	IFile target = getWorkspace().getRoot().getFile(path);
	try {
	target.create(null, true, getMonitor());
	} catch (CoreException e) {
	assertTrue(existing.exists());
	return;
	}
	fail("Should not be able to create file over folder");
	}

	public void testFolderCreation() throws Throwable {
	IPath path = new Path("/testProject/testFolder");
	IFolder target = getWorkspace().getRoot().getFolder(path);
	target.create(true, true, getMonitor());
	assertTrue(target.exists());
	}

	public void testFolderDeletion() throws Throwable {
	IProject project = getTestProject();
	IResource[] before = buildResources(project, new String[] {"c/", "c/b/", "c/x", "c/b/y", "c/b/z"});
	ensureExistsInWorkspace(before, true);
	//
	assertExistsInWorkspace(before);
	project.getFolder("c").delete(true, getMonitor());
	assertDoesNotExistInWorkspace(before);
	}

	public void testFolderMove() throws Throwable {
	IProject project = getTestProject();
	IResource[] before = buildResources(project, new String[] {"b/", "b/b/", "b/x", "b/b/y", "b/b/z"});
	IResource[] after = buildResources(project, new String[] {"a/", "a/b/", "a/x", "a/b/y", "a/b/z"});

	// create the resources and set some content in a file that will be moved.
	ensureExistsInWorkspace(before, true);
	String content = getRandomString();
	IFile file = project.getFile(new Path("b/b/z"));
	file.setContents(getContents(content), true, false, getMonitor());

	// Be sure the resources exist and then move them.
	assertExistsInWorkspace(before);
	project.getFolder("b").move(project.getFullPath().append("a"), true, getMonitor());

	//
	assertDoesNotExistInWorkspace(before);
	assertExistsInWorkspace(after);
	file = project.getFile(new Path("a/b/z"));
	assertTrue("get not equal set", compareContent(getContents(content), file.getContents(false)));
	}

	public void testFolderOverFile() throws Throwable {
	IPath path = new Path("/testProject/testFile");
	IFile existing = getWorkspace().getRoot().getFile(path);
	assertTrue(existing.exists());
	IFolder target = getWorkspace().getRoot().getFolder(path);
	try {
	target.create(true, true, getMonitor());
	} catch (CoreException e) {
	assertTrue(existing.exists());
	return;
	}
	fail("Should not be able to create folder over a file");
	}

	public void testLeafFolderMove() throws Throwable {
	IProject project = getTestProject();
	IFolder source = project.getFolder("testFolder");
	IFolder dest = project.getFolder("movedFolder");
	//
	source.move(dest.getFullPath(), true, getMonitor());
	assertExistsInWorkspace(dest);
	assertDoesNotExistInWorkspace(source);
	}

	public void testMultiCreation() throws Throwable {
	final IProject project = getWorkspace().getRoot().getProject("bar");
	final IResource[] resources = buildResources(project, new String[] {"a/", "a/b"});
	IWorkspaceRunnable body = monitor -> {
	if (!project.exists()) {
	project.create(null);
	}
	if (!project.isOpen()) {
	project.open(null);
	}
	// define an operation which will create a bunch of resources including a project.
	for (IResource resource : resources) {
	switch (resource.getType()) {
	case IResource.FILE :
	((IFile) resource).create(null, false, getMonitor());
	break;
	case IResource.FOLDER :
	((IFolder) resource).create(false, true, getMonitor());
	break;
	case IResource.PROJECT :
	((IProject) resource).create(getMonitor());
	break;
	}
	}
	};
	getWorkspace().run(body, getMonitor());
	assertExistsInWorkspace(project);
	assertExistsInWorkspace(resources);
	}

	public void testMultiDeletion() throws Throwable {
	IProject project = getTestProject();
	IResource[] before = buildResources(project, new String[] {"c/", "c/b/", "c/x", "c/b/y", "c/b/z"});
	ensureExistsInWorkspace(before, true);
	//
	assertExistsInWorkspace(before);
	getWorkspace().delete(before, true, getMonitor());
	assertDoesNotExistInWorkspace(before);
	}

	public void testProjectCloseOpen() throws Throwable {
	IProject target = getTestProject();
	target.close(getMonitor());
	assertTrue(target.exists());
	assertTrue(!target.isOpen());
	assertTrue(!target.getFolder("testFolder").exists());
	target.open(getMonitor());
	assertTrue(target.isOpen());
	assertTrue(target.getFolder("testFolder").exists());
	}

	public void testProjectCreateOpenCloseDelete() throws Throwable {
	IProject target = getTestProject2();
	target.create(null, getMonitor());
	assertTrue(target.exists());
	target.open(getMonitor());
	assertTrue(target.isOpen());
	target.close(getMonitor());
	assertTrue(!target.isOpen());
	target.delete(true, getMonitor());
	assertTrue(!target.exists());
	}

	public void testProjectCreation() throws Throwable {
	IProject target = getTestProject();
	target.create(null, getMonitor());
	assertTrue(target.exists());
	target.open(getMonitor());
	assertTrue(target.isOpen());
	}

	public void testProjectDeletion() throws Throwable {
	IProject target = getTestProject();
	target.delete(true, getMonitor());
	assertTrue("Project Deletion failed", !target.exists());
	}

	public void testWorkingLocationDeletion_bug433061() throws Throwable {
	// Only activate this test if testing of symbolic links is possible.
	if (!canCreateSymLinks()) {
	return;
	}
	IProject project = getTestProject();
	project.create(null, getMonitor());
	IPath workingLocation = project.getWorkingLocation("org.eclipse.core.tests.resources");
	IPath linkTarget = getRandomLocation();
	try {
	linkTarget.toFile().mkdirs();
	File file = linkTarget.append("aFile").toFile();
	assertTrue(file.createNewFile());
	assertTrue(file.exists());
	// Create a symlink in the working location of the project pointing to linkTarget.
	createSymLink(workingLocation.toFile(), "link", linkTarget.toOSString(), true);
	project.delete(true, getMonitor());
	assertTrue("Project deletion failed", !project.exists());
	assertTrue("Working location was not deleted", !workingLocation.toFile().exists());
	assertTrue("File inside a symlinked directory got deleted", file.exists());
	} finally {
	Workspace.clear(linkTarget.toFile());
	}
	}

	public void testProjectReferences() throws Throwable {
	IProject target = getTestProject2();
	target.create(null, getMonitor());
	assertTrue(target.exists());
	IProject project = getTestProject();
	IProjectDescription description = project.getDescription();
	description.setReferencedProjects(new IProject[] {target});
	project.setDescription(description, getMonitor());
	assertTrue(target.getReferencingProjects().length == 1);

	target.delete(true, getMonitor());
	assertTrue(!target.exists());
	}

	public void testSetContents() throws Throwable {
	IPath path = new Path("/testProject/testFile");
	IFile target = getWorkspace().getRoot().getFile(path);
	String testString = getRandomString();
	target.setContents(getContents(testString), true, false, getMonitor());
	InputStream content = null;
	try {
	content = target.getContents(false);
	assertTrue("get not equal set", compareContent(content, getContents(testString)));
	} finally {
	content.close();
	}
	}

	public void testSetGetFilePersistentProperty() throws Throwable {
	IResource target = getWorkspace().getRoot().getFile(new Path("/testProject/testFile"));
	setGetPersistentProperty(target);
	}

	public void testSetGetFolderPersistentProperty() throws Throwable {
	IResource target = getWorkspace().getRoot().getFolder(new Path("/testProject/testFolder"));
	setGetPersistentProperty(target);
	}

	public void testSetGetProjectPersistentProperty() throws Throwable {
	IResource target = getWorkspace().getRoot().getProject("/testProject");
	setGetPersistentProperty(target);
	}

	public void testSetProperty() throws Throwable {
	IPath path = new Path("/testProject/testFile");
	IFile target = getWorkspace().getRoot().getFile(path);
	String value = "this is a test property value";
	QualifiedName name = new QualifiedName("itp-test", "testProperty");
	target.setPersistentProperty(name, value);
	assertTrue("get not equal set", target.getPersistentProperty(name).equals(value));
	}

	public void testSimpleMove() throws Throwable {
	IPath path = new Path("/testProject/simpleFile");
	IFile target = getWorkspace().getRoot().getFile(path);
	target.create(getRandomContents(), true, getMonitor());
	IFile destination = getWorkspace().getRoot().getFile(new Path("/testProject/newSimpleFile"));
	target.move(destination.getFullPath(), true, getMonitor());
	assertTrue(destination.exists());
	assertTrue(!target.exists());
	}
	}