/**
* 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);
}
}
/*
* @see TestCase#setUp()
*/
protected void setUp() throws Exception {
super.setUp();
setAutoBuilding(true);
IWorkspaceRoot root = getWorkspace().getRoot();
project1 = root.getProject("Project1");
project2 = root.getProject("Project2");
project3 = root.getProject("Project3");
project4 = root.getProject("Project4");
file1 = project1.getFile("File1");
file2 = project2.getFile("File2");
file3 = project3.getFile("File3");
file4 = project4.getFile("File4");
IResource[] resources = {project1, project2, project3, project4, file1, file2, file3, file4};
ensureExistsInWorkspace(resources, true);
}
public void testMoveProjectWithVirtualFolder() {
IPath fileLocation = getRandomLocation();
IPath folderLocation = getRandomLocation();
IFile file = existingVirtualFolderInExistingProject.getFile(getUniqueString());
IFolder folder = existingVirtualFolderInExistingProject.getFolder(getUniqueString());
IFile childFile = folder.getFile(getUniqueString());
IResource[] oldResources = new IResource[] {existingProject, file, folder, childFile};
try {
assertDoesNotExistInWorkspace("1.0", new IResource[] {folder, file, childFile});
try {
createFileInFileSystem(fileLocation);
folderLocation.toFile().mkdir();
folder.createLink(folderLocation, IResource.NONE, getMonitor());
file.createLink(fileLocation, IResource.NONE, getMonitor());
childFile.create(getRandomContents(), true, getMonitor());
} catch (CoreException e) {
fail("2.0", e);
}
// move the project
IProject destinationProject = getWorkspace().getRoot().getProject("MoveTargetProject");
assertDoesNotExistInWorkspace("3.0", destinationProject);
try {
existingProject.move(destinationProject.getFullPath(), IResource.SHALLOW, getMonitor());
} catch (CoreException e) {
fail("4.0", e);
}
IFile newFile = destinationProject.getFile(file.getProjectRelativePath());
IFolder newFolder = destinationProject.getFolder(folder.getProjectRelativePath());
IFile newChildFile = newFolder.getFile(childFile.getName());
IResource[] newResources =
new IResource[] {destinationProject, newFile, newFolder, newChildFile};
assertExistsInWorkspace("5.0", newResources);
assertDoesNotExistInWorkspace("6.1", oldResources);
assertTrue("7.0", existingProject.isSynchronized(IResource.DEPTH_INFINITE));
assertTrue("8.0", destinationProject.isSynchronized(IResource.DEPTH_INFINITE));
assertTrue("9.0", newFile.getParent().isVirtual());
assertTrue("10.0", newFile.isLinked());
assertTrue("11.0", newFolder.isLinked());
assertTrue("12.0", newFolder.getParent().isVirtual());
} finally {
Workspace.clear(fileLocation.toFile());
Workspace.clear(folderLocation.toFile());
}
}
public void test01_prepareWorkspace() throws CoreException, URISyntaxException {
IWorkspace workspace = ResourcesPlugin.getWorkspace();
IProject project = workspace.getRoot().getProject("project");
ensureExistsInWorkspace(project, true);
IFile link = project.getFile("link_to_file");
link.createLink(
new URI("bug369177:/dummy_path.txt"), IResource.ALLOW_MISSING_LOCAL, getMonitor());
workspace.save(true, getMonitor());
}
private IWARProduct createBasicProductWithLibraries() throws Exception {
IWARProduct product = createBasicProduct();
IWorkspaceRoot wsRoot = ResourcesPlugin.getWorkspace().getRoot();
IProject project = wsRoot.getProject("warProduct");
if (!project.exists()) {
project.create(null);
project.open(null);
}
IFile jar = project.getFile("test.jar");
if (!jar.exists()) {
File testJar = File.createTempFile("test", ".jar");
FileInputStream stream = new FileInputStream(testJar);
jar.create(stream, true, null);
}
product.addLibrary(jar.getFullPath(), false);
IFile bridge = project.getFile(SERVLETBRIDGE + ".jar");
if (!bridge.exists()) {
File bridgeJar = File.createTempFile(SERVLETBRIDGE, ".jar");
FileInputStream stream = new FileInputStream(bridgeJar);
bridge.create(stream, true, null);
}
product.addLibrary(bridge.getFullPath(), false);
return product;
}
public void testContainsServletBridgeLibrary() throws Exception {
IWARProduct product = createBasicProduct();
IWorkspaceRoot wsRoot = ResourcesPlugin.getWorkspace().getRoot();
IProject project = wsRoot.getProject("warProduct");
if (!project.exists()) {
project.create(null);
project.open(null);
}
IFile jar = project.getFile(SERVLETBRIDGE + ".jar");
if (!jar.exists()) {
File bridge = File.createTempFile(SERVLETBRIDGE, ".jar");
FileInputStream stream = new FileInputStream(bridge);
jar.create(stream, true, null);
}
product.addLibrary(jar.getFullPath(), false);
Validator validator = new Validator(product);
Validation validation = validator.validate();
assertTrue(validation.isValid());
}
/** Test for Bug #5102. Never reproduced but interesting little test, worth keeping around */
public void testPR() throws Exception {
// create a project with a RefreshLocalJavaFileBuilder and a SortBuilder on the classpath
IProject project = getWorkspace().getRoot().getProject("P1");
project.create(null);
project.open(null);
IProjectDescription desc = project.getDescription();
ICommand one = desc.newCommand();
one.setBuilderName(RefreshLocalJavaFileBuilder.BUILDER_NAME);
ICommand two = desc.newCommand();
two.setBuilderName(SortBuilder.BUILDER_NAME);
desc.setBuildSpec(new ICommand[] {one, two});
project.setDescription(desc, null);
// do a full build
project.build(IncrementalProjectBuilder.FULL_BUILD, null);
// do an incremental build by creating a file
IFile file = project.getFile("Foo");
file.create(getRandomContents(), true, getMonitor());
}
public void testCopyProjectWithVirtualFolder() {
IPath fileLocation = getRandomLocation();
IPath folderLocation = getRandomLocation();
IFile linkedFile = existingVirtualFolderInExistingProject.getFile(getUniqueString());
IFolder linkedFolder = existingVirtualFolderInExistingProject.getFolder(getUniqueString());
try {
try {
createFileInFileSystem(fileLocation, getRandomContents());
folderLocation.toFile().mkdir();
linkedFolder.createLink(folderLocation, IResource.NONE, getMonitor());
linkedFile.createLink(fileLocation, IResource.NONE, getMonitor());
} catch (CoreException e) {
fail("1.0", e);
}
// copy the project
IProject destinationProject = getWorkspace().getRoot().getProject("CopyTargetProject");
try {
existingProject.copy(destinationProject.getFullPath(), IResource.SHALLOW, getMonitor());
} catch (CoreException e) {
fail("2.0", e);
}
IFile newFile = destinationProject.getFile(linkedFile.getProjectRelativePath());
assertTrue("3.0", newFile.isLinked());
assertEquals("3.1", linkedFile.getLocation(), newFile.getLocation());
assertTrue("3.2", newFile.getParent().isVirtual());
IFolder newFolder = destinationProject.getFolder(linkedFolder.getProjectRelativePath());
assertTrue("4.0", newFolder.isLinked());
assertEquals("4.1", linkedFolder.getLocation(), newFolder.getLocation());
assertTrue("4.2", newFolder.getParent().isVirtual());
// test project deep copy
try {
destinationProject.delete(IResource.NONE, getMonitor());
existingProject.copy(destinationProject.getFullPath(), IResource.NONE, getMonitor());
} catch (CoreException e) {
fail("5.0", e);
}
assertTrue("5.1", newFile.isLinked());
assertEquals("5.2", linkedFile.getLocation(), newFile.getLocation());
assertTrue("5.3", newFile.getParent().isVirtual());
assertTrue("5.4", newFolder.isLinked());
assertEquals("5.5", linkedFolder.getLocation(), newFolder.getLocation());
assertTrue("5.6", newFolder.getParent().isVirtual());
try {
destinationProject.delete(IResource.NONE, getMonitor());
} catch (CoreException e) {
fail("6.0", e);
}
} finally {
Workspace.clear(fileLocation.toFile());
Workspace.clear(folderLocation.toFile());
}
}
/**
* Creates a locale specific properties file within the fragment project based on the content of
* the host plug-in's properties file.
*
* @param fragmentProject
* @param locale
* @throws CoreException
* @throws IOException
*/
private void createLocaleSpecificPropertiesFile(
final IProject fragmentProject, IPluginModelBase plugin, final Locale locale)
throws CoreException, IOException {
final IFolder localeResourceFolder =
fragmentProject.getFolder(RESOURCE_FOLDER_PARENT).getFolder(locale.toString());
// Case 1: External plug-in
if (plugin instanceof ExternalPluginModelBase) {
final String installLocation = plugin.getInstallLocation();
// Case 1a: External plug-in is a jar file
if (new File(installLocation).isFile()) {
ZipFile zf = new ZipFile(installLocation);
for (Enumeration e = zf.entries(); e.hasMoreElements(); ) {
worked();
ZipEntry zfe = (ZipEntry) e.nextElement();
String name = zfe.getName();
String[] segments = name.split(SLASH);
IPath path = Path.fromPortableString(join(SLASH, segments, 0, segments.length - 1));
String resourceName = segments[segments.length - 1];
String localizedResourceName = localeSpecificName(resourceName, locale);
if (propertiesFilter.include(name)) {
createParents(fragmentProject, path);
IFile file = fragmentProject.getFile(path.append(localizedResourceName));
InputStream is = zf.getInputStream(zfe);
file.create(is, false, getProgressMonitor());
} else if (resourceFilter.include(name)) {
IPath target = localeResourceFolder.getFullPath().append(path).append(resourceName);
createParents(fragmentProject, target.removeLastSegments(1).removeFirstSegments(1));
IFile file = fragmentProject.getFile(target.removeFirstSegments(1));
file.create(zf.getInputStream(zfe), false, getProgressMonitor());
}
}
}
// Case 1b: External plug-in has a folder structure
else {
Visitor visitor =
new Visitor() {
public void visit(File file) throws CoreException, FileNotFoundException {
worked();
String relativePath =
file.getAbsolutePath()
.substring(installLocation.length())
.replaceAll(File.separator, SLASH);
String[] segments = relativePath.split(SLASH);
IPath path = Path.fromPortableString(join(SLASH, segments, 0, segments.length - 1));
String resourceName = segments[segments.length - 1];
String localizedResourceName = localeSpecificName(resourceName, locale);
if (propertiesFilter.include(
relativePath + (file.isDirectory() ? SLASH : EMPTY_STRING))) {
createParents(fragmentProject, path);
IFile iFile = fragmentProject.getFile(path.append(localizedResourceName));
iFile.create(new FileInputStream(file), false, getProgressMonitor());
} else if (resourceFilter.include(
relativePath + (file.isDirectory() ? SLASH : EMPTY_STRING))) {
IPath target = localeResourceFolder.getFullPath().append(relativePath);
createParents(
fragmentProject, target.removeLastSegments(1).removeFirstSegments(1));
IFile iFile = fragmentProject.getFile(target.removeFirstSegments(1));
iFile.create(new FileInputStream(file), false, getProgressMonitor());
}
if (file.isDirectory()) {
File[] children = file.listFiles();
for (int i = 0; i < children.length; i++) {
visit(children[i]);
}
}
}
};
visitor.visit(new File(installLocation));
}
}
// Case 2: Workspace plug-in
else {
final IProject project = plugin.getUnderlyingResource().getProject();
project.accept(
new IResourceVisitor() {
public boolean visit(IResource resource) throws CoreException {
worked();
IPath parent = resource.getFullPath().removeLastSegments(1).removeFirstSegments(1);
if (propertiesFilter.include(resource)) {
String segment = localeSpecificName(resource.getFullPath().lastSegment(), locale);
IPath fragmentResource =
fragmentProject.getFullPath().append(parent).append(segment);
createParents(fragmentProject, parent);
resource.copy(fragmentResource, true, getProgressMonitor());
} else if (resourceFilter.include(resource)) {
IPath target =
localeResourceFolder
.getFullPath()
.append(parent)
.append(resource.getFullPath().lastSegment());
createParents(fragmentProject, target.removeLastSegments(1).removeFirstSegments(1));
resource.copy(target, true, getProgressMonitor());
}
return true;
}
});
}
}
/**
* The worker method. It will create a new project, then create the appropriate Soar heirarchy and
* files.
*/
private void doFinish(String projectName, IProgressMonitor monitor) throws CoreException {
monitor.beginTask("Creating " + projectName, 7);
IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
IProject newProject = root.getProject(projectName);
// creation of the project
if (newProject.exists()) {
throwCoreException("Project \"" + projectName + "\" already exists");
} else {
newProject.create(monitor);
newProject.open(monitor);
try {
IProjectDescription description = newProject.getDescription();
String[] natures = description.getNatureIds();
String[] newNatures = new String[natures.length + 1];
System.arraycopy(natures, 0, newNatures, 0, natures.length);
newNatures[natures.length] = SoarProjectNature.NATURE_ID;
description.setNatureIds(newNatures);
newProject.setDescription(description, IResource.FORCE, monitor);
newProject.setPersistentProperty(DataMap.VERTEX_ID, "0");
} catch (CoreException e) {
e.printStackTrace();
} // catch
} // else
monitor.worked(2);
// Create the contents of the project's root directory
IFolder folderAll = newProject.getFolder("all");
if (!folderAll.exists()) {
folderAll.create(true, true, monitor);
} // if
FileMarker.markResource(folderAll, "file");
IFolder folderElaborations = newProject.getFolder("elaborations");
if (!folderElaborations.exists()) {
folderElaborations.create(true, true, monitor);
} // if
FileMarker.markResource(folderElaborations, "file");
IFile file_firstload = newProject.getFile("_firstload.soar");
if (!file_firstload.exists()) {
file_firstload.create(
Utility.getFileTemplate(file_firstload, "_firstload.soar"), true, monitor);
} // if
FileMarker.markResource(file_firstload, "file");
IFile filedatamap = newProject.getFile("datamap.xdm");
if (!filedatamap.exists()) {
filedatamap.create(Utility.getFileTemplate(filedatamap, "datamap.xdm"), true, monitor);
} // if
monitor.worked(3);
// Create the contents of the elaborations folder
IFile file_all = folderElaborations.getFile("_all.soar");
if (!file_all.exists()) {
file_all.create(Utility.getFileTemplate(file_all, "_all.soar"), true, monitor);
} // if
FileMarker.markResource(file_all, "file");
IFile filetopstate = folderElaborations.getFile("top-state.soar");
if (!filetopstate.exists()) {
filetopstate.create(Utility.getFileTemplate(filetopstate, "top-state.soar"), true, monitor);
} // if
FileMarker.markResource(filetopstate, "file");
SourcingFile.createSourcingFile(newProject, monitor);
newProject.close(monitor);
newProject.open(monitor);
monitor.worked(2);
monitor.done();
} // void doFinish(...)
/** 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 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);
}
}
}
private IFile getSettingsFile() {
return _project.getFile(SETTINGS_FILE);
}
