/*******************************************************************************
* 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));
}
}