tests/org.eclipse.core.tests.resources/src/org/eclipse/core/tests/resources/IFolderTest.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;

 import junit.framework.Test;
 import junit.framework.TestSuite;
 import org.eclipse.core.resources.*;
 import org.eclipse.core.runtime.*;

 public class IFolderTest extends ResourceTest {
 	public static Test suite() {
 		return new TestSuite(IFolderTest.class);
 	}

 	public IFolderTest() {
 		super();
 	}

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

 	@Override
 	protected void setUp() throws Exception {
 		super.setUp();
 	}

 	@Override
 	protected void tearDown() throws Exception {
 		getWorkspace().getRoot().refreshLocal(IResource.DEPTH_INFINITE, null);
 		ensureDoesNotExistInWorkspace(getWorkspace().getRoot());
 		super.tearDown();
 	}

 	public void testChangeCase() {
 		IProject project = getWorkspace().getRoot().getProject("Project");
 		IFolder before = project.getFolder("folder");
 		IFolder after = project.getFolder("Folder");
 		IFile beforeFile = before.getFile("file");
 		IFile afterFile = after.getFile("file");

 		// create the resources and set some content in a file that will be moved.
 		ensureExistsInWorkspace(before, true);
 		try {
 			beforeFile.create(getRandomContents(), false, getMonitor());
 		} catch (CoreException e) {
 			fail("0.99", e);
 		}

 		// Be sure the resources exist and then move them.
 		assertExistsInWorkspace("1.0", before);
 		assertExistsInWorkspace("1.1", beforeFile);
 		assertDoesNotExistInWorkspace("1.2", after);
 		assertDoesNotExistInWorkspace("1.3", afterFile);
 		try {
 			before.move(after.getFullPath(), IResource.NONE, getMonitor());
 		} catch (CoreException e) {
 			fail("1.99", e);
 		}

 		assertDoesNotExistInWorkspace("1.2", before);
 		assertDoesNotExistInWorkspace("1.3", beforeFile);
 		assertExistsInWorkspace("1.0", after);
 		assertExistsInWorkspace("1.1", afterFile);
 	}

 	public void testCopyMissingFolder() {
 		//tests copying a folder that is missing from the file system
 		IProject project = getWorkspace().getRoot().getProject("Project");
 		IFolder before = project.getFolder("OldFolder");
 		IFolder after = project.getFolder("NewFolder");
 		ensureExistsInWorkspace(project, true);
 		ensureExistsInWorkspace(before, true);
 		ensureDoesNotExistInFileSystem(before);

 		try {
 			//should fail because 'before' does not exist in the filesystem
 			before.copy(after.getFullPath(), IResource.FORCE, getMonitor());
 			fail("1.0");
 		} catch (CoreException e) {
 			//should fail
 		}
 		//the destination should not exist, because the source does not exist
 		assertTrue("1.1", !before.exists());
 		assertTrue("1.2", !after.exists());
 	}

 	public void testCreateDerived() {
 		IProject project = getWorkspace().getRoot().getProject("Project");
 		IFolder derived = project.getFolder("derived");
 		ensureExistsInWorkspace(project, true);
 		ensureDoesNotExistInWorkspace(derived);

 		try {
 			derived.create(IResource.DERIVED, true, getMonitor());
 		} catch (CoreException e) {
 			fail("0.99", e);
 		}
 		assertTrue("1.0", derived.isDerived());
 		assertTrue("1.1", !derived.isTeamPrivateMember());
 		try {
 			derived.delete(false, getMonitor());
 			derived.create(IResource.NONE, true, getMonitor());
 		} catch (CoreException e) {
 			fail("1.99", e);
 		}
 		assertTrue("2.0", !derived.isDerived());
 		assertTrue("2.1", !derived.isTeamPrivateMember());
 	}

 	public void testDeltaOnCreateDerived() {
 		IProject project = getWorkspace().getRoot().getProject("Project");
 		IFolder derived = project.getFolder("derived");
 		ensureExistsInWorkspace(project, true);

 		ResourceDeltaVerifier verifier = new ResourceDeltaVerifier();
 		getWorkspace().addResourceChangeListener(verifier, IResourceChangeEvent.POST_CHANGE);

 		verifier.addExpectedChange(derived, IResourceDelta.ADDED, IResource.NONE);

 		try {
 			derived.create(IResource.FORCE | IResource.DERIVED, true, getMonitor());
 		} catch (CoreException e) {
 			fail("1.0", e);
 		}

 		assertTrue("2.0", verifier.isDeltaValid());
 	}

 	public void testCreateDerivedTeamPrivate() {
 		IProject project = getWorkspace().getRoot().getProject("Project");
 		IFolder teamPrivate = project.getFolder("teamPrivate");
 		ensureExistsInWorkspace(project, true);
 		ensureDoesNotExistInWorkspace(teamPrivate);

 		try {
 			teamPrivate.create(IResource.TEAM_PRIVATE | IResource.DERIVED, true, getMonitor());
 		} catch (CoreException e) {
 			fail("0.99", e);
 		}
 		assertTrue("1.0", teamPrivate.isTeamPrivateMember());
 		assertTrue("1.1", teamPrivate.isDerived());
 		try {
 			teamPrivate.delete(false, getMonitor());
 			teamPrivate.create(IResource.NONE, true, getMonitor());
 		} catch (CoreException e) {
 			fail("1.99", e);
 		}
 		assertTrue("2.0", !teamPrivate.isTeamPrivateMember());
 		assertTrue("2.1", !teamPrivate.isDerived());
 	}

 	public void testCreateTeamPrivate() {
 		IProject project = getWorkspace().getRoot().getProject("Project");
 		IFolder teamPrivate = project.getFolder("teamPrivate");
 		ensureExistsInWorkspace(project, true);
 		ensureDoesNotExistInWorkspace(teamPrivate);

 		try {
 			teamPrivate.create(IResource.TEAM_PRIVATE, true, getMonitor());
 		} catch (CoreException e) {
 			fail("0.99", e);
 		}
 		assertTrue("1.0", teamPrivate.isTeamPrivateMember());
 		assertTrue("1.1", !teamPrivate.isDerived());
 		try {
 			teamPrivate.delete(false, getMonitor());
 			teamPrivate.create(IResource.NONE, true, getMonitor());
 		} catch (CoreException e) {
 			fail("1.99", e);
 		}
 		assertTrue("2.0", !teamPrivate.isTeamPrivateMember());
 		assertTrue("2.1", !teamPrivate.isDerived());
 	}

 	public void testFolderCreation() throws Exception {
 		// basic folder creation
 		IProject project = getWorkspace().getRoot().getProject("Project");
 		ensureExistsInWorkspace(project, true);

 		IFolder target = project.getFolder("Folder1");
 		try {
 			assertTrue("1.0", !target.exists());
 			target.create(true, true, getMonitor());
 			assertTrue("1.1", target.exists());
 		} catch (CoreException e) {
 			fail("1.2", e);
 		}

 		// nested folder creation
 		IFolder nestedTarget = target.getFolder("Folder2");
 		try {
 			assertTrue("2.0", !nestedTarget.exists());
 			nestedTarget.create(true, true, getMonitor());
 			assertTrue("2.1", nestedTarget.exists());
 		} catch (CoreException e) {
 			fail("2.2", e);
 		}

 		// try to create a folder that already exists
 		try {
 			assertTrue("3.0", target.exists());
 			target.create(true, true, getMonitor());
 			fail("3.1");
 		} catch (CoreException e) {
 			assertTrue("3.2", target.exists());
 		}

 		// try to create a folder over a file that exists
 		IFile file = target.getFile("File1");
 		target = target.getFolder("File1");
 		try {
 			file.create(getRandomContents(), true, getMonitor());
 			assertTrue("4.0", file.exists());
 		} catch (CoreException e) {
 			fail("4.1", e);
 		}

 		try {
 			target.create(true, true, getMonitor());
 			fail("5.0");
 		} catch (CoreException e) {
 			assertTrue("5.1", file.exists());
 			assertTrue("5.2", !target.exists());
 		}

 		// try to create a folder on a project (one segment) path
 		try {
 			target = getWorkspace().getRoot().getFolder(new Path("/Folder3"));
 			fail("6.0");
 		} catch (IllegalArgumentException e) {
 			// expected
 		}

 		// try to create a folder as a child of a file
 		file = project.getFile("File2");
 		try {
 			file.create(null, true, getMonitor());
 		} catch (CoreException e) {
 			fail("7.0", e);
 		}

 		target = project.getFolder("File2/Folder4");
 		try {
 			assertTrue("7.1", !target.exists());
 			target.create(true, true, getMonitor());
 			fail("7.2");
 		} catch (CoreException e) {
 			assertTrue("7.3", file.exists());
 			assertTrue("7.4", !target.exists());
 		}

 		// try to create a folder under a non-existant parent
 		IFolder folder = project.getFolder("Folder5");
 		target = folder.getFolder("Folder6");
 		try {
 			assertTrue("8.0", !folder.exists());
 			target.create(true, true, getMonitor());
 			fail("8.1");
 		} catch (CoreException e) {
 			assertTrue("8.2", !folder.exists());
 			assertTrue("8.3", !target.exists());
 		}
 	}

 	public void testFolderDeletion() throws Throwable {
 		IProject project = getWorkspace().getRoot().getProject("Project");
 		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("1.0", before);
 	}

 	public void testFolderMove() throws Throwable {
 		IProject project = getWorkspace().getRoot().getProject("Project");
 		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("1.0", before);
 		project.getFolder("b").move(project.getFullPath().append("a"), true, getMonitor());

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

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

 	/**
 	 * Tests creation and manipulation of folder names that are reserved on some platforms.
 	 */
 	public void testInvalidFolderNames() {
 		IProject project = getWorkspace().getRoot().getProject("Project");
 		ensureExistsInWorkspace(project, true);

 		//do some tests with invalid names
 		String[] names = new String[0];
 		if (isWindows()) {
 			//invalid windows names
 			names = new String[] {"prn", "nul", "con", "aux", "clock$", "com1", "com2", "com3", "com4", "com5", "com6", "com7", "com8", "com9", "lpt1", "lpt2", "lpt3", "lpt4", "lpt5", "lpt6", "lpt7", "lpt8", "lpt9", "AUX", "con.foo", "LPT4.txt", "*", "?", "\"", "<", ">", "|"};
 		} else {
 			//invalid names on non-windows platforms
 			names = new String[] {};
 		}

 		for (String name : names) {
 			IFolder folder = project.getFolder(name);
 			assertTrue("1.0 " + name, !folder.exists());
 			try {
 				folder.create(true, true, getMonitor());
 				fail("1.1 " + name);
 			} catch (CoreException e) {
 				// expected
 			}
 			assertTrue("1.2 " + name, !folder.exists());
 		}

 		//do some tests with valid names that are *almost* invalid
 		if (isWindows()) {
 			//these names are valid on windows
 			names = new String[] {"hello.prn.txt", "null", "con3", "foo.aux", "lpt0", "com0", "com10", "lpt10", ",", "'", ";"};
 		} else {
 			//these names are valid on non-windows platforms
 			names = new String[] {"prn", "nul", "con", "aux", "clock$", "com1", "com2", "com3", "com4", "com5", "com6", "com7", "com8", "com9", "lpt1", "lpt2", "lpt3", "lpt4", "lpt5", "lpt6", "lpt7", "lpt8", "lpt9", "con.foo", "LPT4.txt", "*", "?", "\"", "<", ">", "|", "hello.prn.txt", "null", "con3", "foo.aux", "lpt0", "com0", "com10", "lpt10", ",", "'", ";"};
 		}
 		for (String name : names) {
 			IFolder folder = project.getFolder(name);
 			assertTrue("2.0 " + name, !folder.exists());
 			try {
 				folder.create(true, true, getMonitor());
 			} catch (CoreException e) {
 				fail("2.1 " + name, e);
 			}
 			assertTrue("2.2 " + name, folder.exists());
 		}
 	}

 	public void testLeafFolderMove() throws Exception {
 		IProject project = getWorkspace().getRoot().getProject("Project");
 		IFolder source = project.getFolder("Folder1");
 		ensureExistsInWorkspace(source, true);
 		IFolder dest = project.getFolder("Folder2");
 		source.move(dest.getFullPath(), true, getMonitor());
 		assertExistsInWorkspace("1.0", dest);
 		assertDoesNotExistInWorkspace("1.1", source);
 	}

 	public void testReadOnlyFolderCopy() throws Exception {
 		// We need to know whether or not we can unset the read-only flag
 		// in order to perform this test.
 		if (!isReadOnlySupported()) {
 			return;
 		}
 		IProject project = getWorkspace().getRoot().getProject("Project");
 		IFolder source = project.getFolder("Folder1");
 		ensureExistsInWorkspace(source, true);
 		source.setReadOnly(true);
 		IFolder dest = project.getFolder("Folder2");
 		source.copy(dest.getFullPath(), true, getMonitor());
 		assertExistsInWorkspace("1.0", dest);
 		assertExistsInWorkspace("1.1", source);
 		assertTrue("1.2", dest.isReadOnly());

 		// cleanup - ensure that the files can be deleted.
 		source.setReadOnly(false);
 		dest.setReadOnly(false);
 	}

 	public void testSetGetFolderPersistentProperty() throws Throwable {
 		IResource target = getWorkspace().getRoot().getFolder(new Path("/Project/Folder"));
 		String value = "this is a test property value";
 		QualifiedName name = new QualifiedName("itp-test", "testProperty");
 		// getting/setting persistent properties on non-existent resources should throw an exception
 		ensureDoesNotExistInWorkspace(target);
 		try {
 			target.getPersistentProperty(name);
 			fail("1.0");
 		} catch (CoreException e) {
 			//this should happen
 		}
 		try {
 			target.setPersistentProperty(name, value);
 			fail("1.1");
 		} catch (CoreException e) {
 			//this should happen
 		}

 		ensureExistsInWorkspace(target, true);
 		target.setPersistentProperty(name, value);
 		// see if we can get the property
 		assertTrue("2.0", target.getPersistentProperty(name).equals(value));
 		// see what happens if we get a non-existant property
 		name = new QualifiedName("itp-test", "testNonProperty");
 		assertNull("2.1", target.getPersistentProperty(name));
 	}
 }
	/*******************************************************************************
	* 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;

	import junit.framework.Test;
	import junit.framework.TestSuite;
	import org.eclipse.core.resources.*;
	import org.eclipse.core.runtime.*;

	public class IFolderTest extends ResourceTest {
	public static Test suite() {
	return new TestSuite(IFolderTest.class);
	}

	public IFolderTest() {
	super();
	}

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

	@Override
	protected void setUp() throws Exception {
	super.setUp();
	}

	@Override
	protected void tearDown() throws Exception {
	getWorkspace().getRoot().refreshLocal(IResource.DEPTH_INFINITE, null);
	ensureDoesNotExistInWorkspace(getWorkspace().getRoot());
	super.tearDown();
	}

	public void testChangeCase() {
	IProject project = getWorkspace().getRoot().getProject("Project");
	IFolder before = project.getFolder("folder");
	IFolder after = project.getFolder("Folder");
	IFile beforeFile = before.getFile("file");
	IFile afterFile = after.getFile("file");

	// create the resources and set some content in a file that will be moved.
	ensureExistsInWorkspace(before, true);
	try {
	beforeFile.create(getRandomContents(), false, getMonitor());
	} catch (CoreException e) {
	fail("0.99", e);
	}

	// Be sure the resources exist and then move them.
	assertExistsInWorkspace("1.0", before);
	assertExistsInWorkspace("1.1", beforeFile);
	assertDoesNotExistInWorkspace("1.2", after);
	assertDoesNotExistInWorkspace("1.3", afterFile);
	try {
	before.move(after.getFullPath(), IResource.NONE, getMonitor());
	} catch (CoreException e) {
	fail("1.99", e);
	}

	assertDoesNotExistInWorkspace("1.2", before);
	assertDoesNotExistInWorkspace("1.3", beforeFile);
	assertExistsInWorkspace("1.0", after);
	assertExistsInWorkspace("1.1", afterFile);
	}

	public void testCopyMissingFolder() {
	//tests copying a folder that is missing from the file system
	IProject project = getWorkspace().getRoot().getProject("Project");
	IFolder before = project.getFolder("OldFolder");
	IFolder after = project.getFolder("NewFolder");
	ensureExistsInWorkspace(project, true);
	ensureExistsInWorkspace(before, true);
	ensureDoesNotExistInFileSystem(before);

	try {
	//should fail because 'before' does not exist in the filesystem
	before.copy(after.getFullPath(), IResource.FORCE, getMonitor());
	fail("1.0");
	} catch (CoreException e) {
	//should fail
	}
	//the destination should not exist, because the source does not exist
	assertTrue("1.1", !before.exists());
	assertTrue("1.2", !after.exists());
	}

	public void testCreateDerived() {
	IProject project = getWorkspace().getRoot().getProject("Project");
	IFolder derived = project.getFolder("derived");
	ensureExistsInWorkspace(project, true);
	ensureDoesNotExistInWorkspace(derived);

	try {
	derived.create(IResource.DERIVED, true, getMonitor());
	} catch (CoreException e) {
	fail("0.99", e);
	}
	assertTrue("1.0", derived.isDerived());
	assertTrue("1.1", !derived.isTeamPrivateMember());
	try {
	derived.delete(false, getMonitor());
	derived.create(IResource.NONE, true, getMonitor());
	} catch (CoreException e) {
	fail("1.99", e);
	}
	assertTrue("2.0", !derived.isDerived());
	assertTrue("2.1", !derived.isTeamPrivateMember());
	}

	public void testDeltaOnCreateDerived() {
	IProject project = getWorkspace().getRoot().getProject("Project");
	IFolder derived = project.getFolder("derived");
	ensureExistsInWorkspace(project, true);

	ResourceDeltaVerifier verifier = new ResourceDeltaVerifier();
	getWorkspace().addResourceChangeListener(verifier, IResourceChangeEvent.POST_CHANGE);

	verifier.addExpectedChange(derived, IResourceDelta.ADDED, IResource.NONE);

	try {
	derived.create(IResource.FORCE \| IResource.DERIVED, true, getMonitor());
	} catch (CoreException e) {
	fail("1.0", e);
	}

	assertTrue("2.0", verifier.isDeltaValid());
	}

	public void testCreateDerivedTeamPrivate() {
	IProject project = getWorkspace().getRoot().getProject("Project");
	IFolder teamPrivate = project.getFolder("teamPrivate");
	ensureExistsInWorkspace(project, true);
	ensureDoesNotExistInWorkspace(teamPrivate);

	try {
	teamPrivate.create(IResource.TEAM_PRIVATE \| IResource.DERIVED, true, getMonitor());
	} catch (CoreException e) {
	fail("0.99", e);
	}
	assertTrue("1.0", teamPrivate.isTeamPrivateMember());
	assertTrue("1.1", teamPrivate.isDerived());
	try {
	teamPrivate.delete(false, getMonitor());
	teamPrivate.create(IResource.NONE, true, getMonitor());
	} catch (CoreException e) {
	fail("1.99", e);
	}
	assertTrue("2.0", !teamPrivate.isTeamPrivateMember());
	assertTrue("2.1", !teamPrivate.isDerived());
	}

	public void testCreateTeamPrivate() {
	IProject project = getWorkspace().getRoot().getProject("Project");
	IFolder teamPrivate = project.getFolder("teamPrivate");
	ensureExistsInWorkspace(project, true);
	ensureDoesNotExistInWorkspace(teamPrivate);

	try {
	teamPrivate.create(IResource.TEAM_PRIVATE, true, getMonitor());
	} catch (CoreException e) {
	fail("0.99", e);
	}
	assertTrue("1.0", teamPrivate.isTeamPrivateMember());
	assertTrue("1.1", !teamPrivate.isDerived());
	try {
	teamPrivate.delete(false, getMonitor());
	teamPrivate.create(IResource.NONE, true, getMonitor());
	} catch (CoreException e) {
	fail("1.99", e);
	}
	assertTrue("2.0", !teamPrivate.isTeamPrivateMember());
	assertTrue("2.1", !teamPrivate.isDerived());
	}

	public void testFolderCreation() throws Exception {
	// basic folder creation
	IProject project = getWorkspace().getRoot().getProject("Project");
	ensureExistsInWorkspace(project, true);

	IFolder target = project.getFolder("Folder1");
	try {
	assertTrue("1.0", !target.exists());
	target.create(true, true, getMonitor());
	assertTrue("1.1", target.exists());
	} catch (CoreException e) {
	fail("1.2", e);
	}

	// nested folder creation
	IFolder nestedTarget = target.getFolder("Folder2");
	try {
	assertTrue("2.0", !nestedTarget.exists());
	nestedTarget.create(true, true, getMonitor());
	assertTrue("2.1", nestedTarget.exists());
	} catch (CoreException e) {
	fail("2.2", e);
	}

	// try to create a folder that already exists
	try {
	assertTrue("3.0", target.exists());
	target.create(true, true, getMonitor());
	fail("3.1");
	} catch (CoreException e) {
	assertTrue("3.2", target.exists());
	}

	// try to create a folder over a file that exists
	IFile file = target.getFile("File1");
	target = target.getFolder("File1");
	try {
	file.create(getRandomContents(), true, getMonitor());
	assertTrue("4.0", file.exists());
	} catch (CoreException e) {
	fail("4.1", e);
	}

	try {
	target.create(true, true, getMonitor());
	fail("5.0");
	} catch (CoreException e) {
	assertTrue("5.1", file.exists());
	assertTrue("5.2", !target.exists());
	}

	// try to create a folder on a project (one segment) path
	try {
	target = getWorkspace().getRoot().getFolder(new Path("/Folder3"));
	fail("6.0");
	} catch (IllegalArgumentException e) {
	// expected
	}

	// try to create a folder as a child of a file
	file = project.getFile("File2");
	try {
	file.create(null, true, getMonitor());
	} catch (CoreException e) {
	fail("7.0", e);
	}

	target = project.getFolder("File2/Folder4");
	try {
	assertTrue("7.1", !target.exists());
	target.create(true, true, getMonitor());
	fail("7.2");
	} catch (CoreException e) {
	assertTrue("7.3", file.exists());
	assertTrue("7.4", !target.exists());
	}

	// try to create a folder under a non-existant parent
	IFolder folder = project.getFolder("Folder5");
	target = folder.getFolder("Folder6");
	try {
	assertTrue("8.0", !folder.exists());
	target.create(true, true, getMonitor());
	fail("8.1");
	} catch (CoreException e) {
	assertTrue("8.2", !folder.exists());
	assertTrue("8.3", !target.exists());
	}
	}

	public void testFolderDeletion() throws Throwable {
	IProject project = getWorkspace().getRoot().getProject("Project");
	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("1.0", before);
	}

	public void testFolderMove() throws Throwable {
	IProject project = getWorkspace().getRoot().getProject("Project");
	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("1.0", before);
	project.getFolder("b").move(project.getFullPath().append("a"), true, getMonitor());

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

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

	/**
	* Tests creation and manipulation of folder names that are reserved on some platforms.
	*/
	public void testInvalidFolderNames() {
	IProject project = getWorkspace().getRoot().getProject("Project");
	ensureExistsInWorkspace(project, true);

	//do some tests with invalid names
	String[] names = new String[0];
	if (isWindows()) {
	//invalid windows names
	names = new String[] {"prn", "nul", "con", "aux", "clock$", "com1", "com2", "com3", "com4", "com5", "com6", "com7", "com8", "com9", "lpt1", "lpt2", "lpt3", "lpt4", "lpt5", "lpt6", "lpt7", "lpt8", "lpt9", "AUX", "con.foo", "LPT4.txt", "*", "?", "\"", "<", ">", "\|"};
	} else {
	//invalid names on non-windows platforms
	names = new String[] {};
	}

	for (String name : names) {
	IFolder folder = project.getFolder(name);
	assertTrue("1.0 " + name, !folder.exists());
	try {
	folder.create(true, true, getMonitor());
	fail("1.1 " + name);
	} catch (CoreException e) {
	// expected
	}
	assertTrue("1.2 " + name, !folder.exists());
	}

	//do some tests with valid names that are almost invalid
	if (isWindows()) {
	//these names are valid on windows
	names = new String[] {"hello.prn.txt", "null", "con3", "foo.aux", "lpt0", "com0", "com10", "lpt10", ",", "'", ";"};
	} else {
	//these names are valid on non-windows platforms
	names = new String[] {"prn", "nul", "con", "aux", "clock$", "com1", "com2", "com3", "com4", "com5", "com6", "com7", "com8", "com9", "lpt1", "lpt2", "lpt3", "lpt4", "lpt5", "lpt6", "lpt7", "lpt8", "lpt9", "con.foo", "LPT4.txt", "*", "?", "\"", "<", ">", "\|", "hello.prn.txt", "null", "con3", "foo.aux", "lpt0", "com0", "com10", "lpt10", ",", "'", ";"};
	}
	for (String name : names) {
	IFolder folder = project.getFolder(name);
	assertTrue("2.0 " + name, !folder.exists());
	try {
	folder.create(true, true, getMonitor());
	} catch (CoreException e) {
	fail("2.1 " + name, e);
	}
	assertTrue("2.2 " + name, folder.exists());
	}
	}

	public void testLeafFolderMove() throws Exception {
	IProject project = getWorkspace().getRoot().getProject("Project");
	IFolder source = project.getFolder("Folder1");
	ensureExistsInWorkspace(source, true);
	IFolder dest = project.getFolder("Folder2");
	source.move(dest.getFullPath(), true, getMonitor());
	assertExistsInWorkspace("1.0", dest);
	assertDoesNotExistInWorkspace("1.1", source);
	}

	public void testReadOnlyFolderCopy() throws Exception {
	// We need to know whether or not we can unset the read-only flag
	// in order to perform this test.
	if (!isReadOnlySupported()) {
	return;
	}
	IProject project = getWorkspace().getRoot().getProject("Project");
	IFolder source = project.getFolder("Folder1");
	ensureExistsInWorkspace(source, true);
	source.setReadOnly(true);
	IFolder dest = project.getFolder("Folder2");
	source.copy(dest.getFullPath(), true, getMonitor());
	assertExistsInWorkspace("1.0", dest);
	assertExistsInWorkspace("1.1", source);
	assertTrue("1.2", dest.isReadOnly());

	// cleanup - ensure that the files can be deleted.
	source.setReadOnly(false);
	dest.setReadOnly(false);
	}

	public void testSetGetFolderPersistentProperty() throws Throwable {
	IResource target = getWorkspace().getRoot().getFolder(new Path("/Project/Folder"));
	String value = "this is a test property value";
	QualifiedName name = new QualifiedName("itp-test", "testProperty");
	// getting/setting persistent properties on non-existent resources should throw an exception
	ensureDoesNotExistInWorkspace(target);
	try {
	target.getPersistentProperty(name);
	fail("1.0");
	} catch (CoreException e) {
	//this should happen
	}
	try {
	target.setPersistentProperty(name, value);
	fail("1.1");
	} catch (CoreException e) {
	//this should happen
	}

	ensureExistsInWorkspace(target, true);
	target.setPersistentProperty(name, value);
	// see if we can get the property
	assertTrue("2.0", target.getPersistentProperty(name).equals(value));
	// see what happens if we get a non-existant property
	name = new QualifiedName("itp-test", "testNonProperty");
	assertNull("2.1", target.getPersistentProperty(name));
	}
	}