/**
* 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);
}
}
protected boolean writeClassFileCheck(IFile file, String fileName, byte[] newBytes)
throws CoreException {
try {
byte[] oldBytes = Util.getResourceContentsAsByteArray(file);
notEqual:
if (newBytes.length == oldBytes.length) {
for (int i = newBytes.length; --i >= 0; ) if (newBytes[i] != oldBytes[i]) break notEqual;
return false; // bytes are identical so skip them
}
URI location = file.getLocationURI();
if (location == null) return false; // unable to determine location of this class file
String filePath = location.getSchemeSpecificPart();
ClassFileReader reader = new ClassFileReader(oldBytes, filePath.toCharArray());
// ignore local types since they're only visible inside a single method
if (!(reader.isLocal() || reader.isAnonymous()) && reader.hasStructuralChanges(newBytes)) {
if (JavaBuilder.DEBUG)
System.out.println("Type has structural changes " + fileName); // $NON-NLS-1$
addDependentsOf(new Path(fileName), true);
this.newState.wasStructurallyChanged(fileName);
}
} catch (ClassFormatException e) {
addDependentsOf(new Path(fileName), true);
this.newState.wasStructurallyChanged(fileName);
}
return true;
}
protected void removeClassFile(IPath typePath, IContainer outputFolder) throws CoreException {
if (typePath.lastSegment().indexOf('$') == -1) { // is not a nested type
this.newState.removeQualifiedTypeName(typePath.toString());
// add dependents even when the type thinks it does not exist to be on the safe side
if (JavaBuilder.DEBUG) System.out.println("Found removed type " + typePath); // $NON-NLS-1$
addDependentsOf(
typePath,
true); // when member types are removed, their enclosing type is structurally changed
}
IFile classFile =
outputFolder.getFile(typePath.addFileExtension(SuffixConstants.EXTENSION_class));
if (classFile.exists()) {
if (JavaBuilder.DEBUG)
System.out.println("Deleting class file of removed type " + typePath); // $NON-NLS-1$
classFile.delete(IResource.FORCE, null);
}
}
protected void refreshFile(IFile file, IProgressMonitor monitor) throws CoreException {
if (file != null) {
try {
file.refreshLocal(IResource.DEPTH_INFINITE, monitor);
} catch (OperationCanceledException x) {
// do nothing
}
}
}
private static void setUpProject() throws Exception {
IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
IProject project = root.getProject("test.rap");
if (!project.exists()) {
project.create(null);
project.open(null);
}
IFolder webInf = project.getFolder("WEB-INF");
if (!webInf.exists()) {
webInf.create(true, true, null);
}
IFile file = webInf.getFile("web.xml");
if (!file.exists()) {
File tempFile = File.createTempFile("test", ".xml");
FileInputStream stream = new FileInputStream(tempFile);
file.create(stream, true, null);
}
}
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());
}
protected void deleteGeneratedFiles(IFile[] deletedGeneratedFiles) {
// delete generated files and recompile any affected source files
try {
for (int j = deletedGeneratedFiles.length; --j >= 0; ) {
IFile deletedFile = deletedGeneratedFiles[j];
if (deletedFile.exists())
continue; // only delete .class files for source files that were actually deleted
SourceFile sourceFile = findSourceFile(deletedFile, false);
String typeLocator = sourceFile.typeLocator();
int mdSegmentCount = sourceFile.sourceLocation.sourceFolder.getFullPath().segmentCount();
IPath typePath =
sourceFile
.resource
.getFullPath()
.removeFirstSegments(mdSegmentCount)
.removeFileExtension();
addDependentsOf(typePath, true); // add dependents of the source file since its now deleted
this.previousSourceFiles =
null; // existing source files did not see it as deleted since they were compiled before
// it was
char[][] definedTypeNames = this.newState.getDefinedTypeNamesFor(typeLocator);
if (definedTypeNames == null) { // defined a single type matching typePath
removeClassFile(typePath, sourceFile.sourceLocation.binaryFolder);
} else {
if (definedTypeNames.length > 0) { // skip it if it failed to successfully define a type
IPath packagePath = typePath.removeLastSegments(1);
for (int d = 0, l = definedTypeNames.length; d < l; d++)
removeClassFile(
packagePath.append(new String(definedTypeNames[d])),
sourceFile.sourceLocation.binaryFolder);
}
}
this.newState.removeLocator(typeLocator);
}
} catch (CoreException e) {
// must continue with compile loop so just log the CoreException
Util.log(
e,
"JavaBuilder logging CompilationParticipant's CoreException to help debugging"); //$NON-NLS-1$
}
}
/** Tries to delete a folder containing an unremovable file. Works only for Windows. */
public void testDeleteFolderWindows() {
if (!isWindows()) return;
IProject project = null;
InputStream input = null;
File projectRoot = null;
try {
IWorkspace workspace = getWorkspace();
project = workspace.getRoot().getProject(getUniqueString());
IFolder folder = project.getFolder("a_folder");
IFile file1 = folder.getFile("file1.txt");
IFile file3 = folder.getFile("file3.txt");
ensureExistsInWorkspace(new IResource[] {file1, file3}, true);
projectRoot = project.getLocation().toFile();
// opens a file so it cannot be removed on Windows
try {
input = file1.getContents();
} catch (CoreException ce) {
ce.printStackTrace();
fail("1.0");
}
try {
folder.delete(IResource.FORCE, getMonitor());
fail("2.0 - should have failed");
} catch (CoreException ce) {
// success - a file couldn't be removed
}
assertTrue("2.2", file1.exists());
assertTrue("2.4", !file3.exists());
assertTrue("2.5", folder.exists());
assertTrue("2.7", folder.isSynchronized(IResource.DEPTH_INFINITE));
assertClose(input);
assertTrue("3.5", project.isSynchronized(IResource.DEPTH_INFINITE));
try {
folder.delete(IResource.FORCE, getMonitor());
} catch (CoreException ce) {
ce.printStackTrace();
fail("4.0", ce);
}
assertTrue("5.1", !file1.exists());
assertTrue("5.2", !folder.exists());
assertTrue("5.3", file1.isSynchronized(IResource.DEPTH_INFINITE));
assertTrue("5.4", folder.isSynchronized(IResource.DEPTH_INFINITE));
} finally {
try {
assertClose(input);
} finally {
if (projectRoot != null) ensureDoesNotExistInFileSystem(projectRoot);
}
}
}
/**
* The worker method. It will find the container, create the file if missing or just replace its
* contents, and open the editor on the newly created file.
*/
private void doFinish(String containerName, String fileName, IProgressMonitor monitor)
throws CoreException {
// create a sample file
monitor.beginTask("Creating " + fileName, 2);
IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
IResource resource = root.findMember(new Path(containerName));
if (!resource.exists() || !(resource instanceof IContainer)) {
throwCoreException("Container \"" + containerName + "\" does not exist.");
}
IContainer container = (IContainer) resource;
final IFile file = container.getFile(new Path(fileName));
try {
InputStream stream = openContentStream();
if (file.exists()) {
file.setContents(stream, true, true, monitor);
} else {
file.create(stream, true, monitor);
}
stream.close();
} catch (IOException e) {
}
monitor.worked(1);
monitor.setTaskName("Opening file for editing...");
getShell()
.getDisplay()
.asyncExec(
new Runnable() {
public void run() {
IWorkbenchPage page =
PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
try {
IDE.openEditor(page, file, true);
} catch (PartInitException e) {
}
}
});
monitor.worked(1);
}
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;
}
/**
* @see
* org.eclipse.jdt.internal.core.builder.AbstractImageBuilder#writeClassFileContents(org.eclipse.jdt.internal.compiler.ClassFile,
* org.eclipse.core.resources.IFile, java.lang.String, boolean,
* org.eclipse.jdt.internal.core.builder.SourceFile)
*/
protected void writeClassFileContents(
ClassFile classfile,
IFile file,
String qualifiedFileName,
boolean isTopLevelType,
SourceFile compilationUnit)
throws CoreException {
// Before writing out the class file, compare it to the previous file
// If structural changes occurred then add dependent source files
byte[] bytes = classfile.getBytes();
if (file.exists()) {
if (writeClassFileCheck(file, qualifiedFileName, bytes)
|| compilationUnit.updateClassFile) { // see 46093
if (JavaBuilder.DEBUG)
System.out.println("Writing changed class file " + file.getName()); // $NON-NLS-1$
if (!file.isDerived()) file.setDerived(true, null);
file.setContents(new ByteArrayInputStream(bytes), true, false, null);
} else if (JavaBuilder.DEBUG) {
System.out.println("Skipped over unchanged class file " + file.getName()); // $NON-NLS-1$
}
} else {
if (isTopLevelType) addDependentsOf(new Path(qualifiedFileName), true); // new type
if (JavaBuilder.DEBUG)
System.out.println("Writing new class file " + file.getName()); // $NON-NLS-1$
try {
file.create(new ByteArrayInputStream(bytes), IResource.FORCE | IResource.DERIVED, null);
} catch (CoreException e) {
if (e.getStatus().getCode() == IResourceStatus.CASE_VARIANT_EXISTS) {
IStatus status = e.getStatus();
if (status instanceof IResourceStatus) {
IPath oldFilePath = ((IResourceStatus) status).getPath();
char[] oldTypeName = oldFilePath.removeFileExtension().lastSegment().toCharArray();
char[][] previousTypeNames =
this.newState.getDefinedTypeNamesFor(compilationUnit.typeLocator());
boolean fromSameFile = false;
if (previousTypeNames == null) {
fromSameFile = CharOperation.equals(compilationUnit.getMainTypeName(), oldTypeName);
} else {
for (int i = 0, l = previousTypeNames.length; i < l; i++) {
if (CharOperation.equals(previousTypeNames[i], oldTypeName)) {
fromSameFile = true;
break;
}
}
}
if (fromSameFile) {
// file is defined by the same compilationUnit, but won't be deleted until later so do
// it now
IFile collision = file.getParent().getFile(new Path(oldFilePath.lastSegment()));
collision.delete(true, false, null);
boolean success = false;
try {
file.create(
new ByteArrayInputStream(bytes), IResource.FORCE | IResource.DERIVED, null);
success = true;
} catch (CoreException ignored) {
// ignore the second exception
}
if (success) return;
}
}
// catch the case that a type has been renamed and collides on disk with an
// as-yet-to-be-deleted type
throw new AbortCompilation(true, new AbortIncrementalBuildException(qualifiedFileName));
}
throw e; // rethrow
}
}
}
/**
* 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;
}
});
}
}
@Override
public boolean visit(IResourceDelta delta) throws CoreException {
if (delta == null) {
return false;
}
IFile file = getFile();
if (file == null) {
return false;
}
delta = delta.findMember(file.getFullPath());
if (delta == null) {
return false;
}
Runnable runnable = null;
switch (delta.getKind()) {
case IResourceDelta.CHANGED:
FileInfo info = (FileInfo) getElementInfo(fileEditorInput);
if (info == null || !canRefreshFromFile(info)) {
break;
}
boolean isSynchronized = computeModificationStamp(file) == info.modificationStamp;
if ((IResourceDelta.ENCODING & delta.getFlags()) != 0 && isSynchronized) {
runnable =
new SafeChange(fileEditorInput) {
@Override
protected void execute(IEditorInput input) throws Exception {
handleElementContentChanged(input);
}
};
}
if (runnable == null
&& (IResourceDelta.CONTENT & delta.getFlags()) != 0
&& !isSynchronized) {
runnable =
new SafeChange(fileEditorInput) {
@Override
protected void execute(IEditorInput input) throws Exception {
handleElementContentChanged(input);
}
};
}
break;
case IResourceDelta.REMOVED:
if ((IResourceDelta.MOVED_TO & delta.getFlags()) != 0) {
final IPath path = delta.getMovedToPath();
runnable =
new SafeChange(fileEditorInput) {
@Override
protected void execute(IEditorInput input) throws Exception {
handleElementMoved(input, path);
}
};
} else {
info = (FileInfo) getElementInfo(fileEditorInput);
if (info != null && canRefreshFromFile(info)) {
runnable =
new SafeChange(fileEditorInput) {
@Override
protected void execute(IEditorInput input) throws Exception {
handleElementDeleted(input);
}
};
}
}
break;
}
if (runnable != null) {
update(runnable);
}
return false;
}
@Override
protected void doSaveDocument(
IProgressMonitor monitor, Object element, IDocument document, boolean overwrite)
throws CoreException {
try {
IStorage storage = EditorUtils.getStorageFromInput(element);
File localFile = null;
if (storage == null) {
localFile = EditorUtils.getLocalFileFromInput(element);
if (localFile == null) {
throw new DBException("Can't obtain file from editor input");
}
}
String encoding =
(storage instanceof IEncodedStorage
? ((IEncodedStorage) storage).getCharset()
: GeneralUtils.DEFAULT_FILE_CHARSET_NAME);
Charset charset = Charset.forName(encoding);
CharsetEncoder encoder = charset.newEncoder();
encoder.onMalformedInput(CodingErrorAction.REPLACE);
encoder.onUnmappableCharacter(CodingErrorAction.REPORT);
byte[] bytes;
ByteBuffer byteBuffer = encoder.encode(CharBuffer.wrap(document.get()));
if (byteBuffer.hasArray()) {
bytes = byteBuffer.array();
} else {
bytes = new byte[byteBuffer.limit()];
byteBuffer.get(bytes);
}
InputStream stream = new ByteArrayInputStream(bytes, 0, byteBuffer.limit());
if (storage instanceof IFile) {
IFile file = (IFile) storage;
if (file.exists()) {
// inform about the upcoming content change
fireElementStateChanging(element);
try {
file.setContents(stream, true, true, monitor);
} catch (CoreException x) {
// inform about failure
fireElementStateChangeFailed(element);
throw x;
} catch (RuntimeException x) {
// inform about failure
fireElementStateChangeFailed(element);
throw x;
}
} else {
try {
monitor.beginTask("Save file '" + file.getName() + "'", 2000);
// ContainerCreator creator = new ContainerCreator(file.getWorkspace(),
// file.getParent().getFullPath());
// creator.createContainer(new SubProgressMonitor(monitor, 1000));
file.create(stream, false, monitor);
} finally {
monitor.done();
}
}
} else if (storage instanceof IPersistentStorage) {
monitor.beginTask("Save document", 1);
((IPersistentStorage) storage).setContents(monitor, stream);
} else if (localFile != null) {
try (OutputStream os = new FileOutputStream(localFile)) {
IOUtils.copyStream(stream, os);
}
} else {
throw new DBException("Storage [" + storage + "] doesn't support save");
}
} catch (Exception e) {
if (e instanceof CoreException) {
throw (CoreException) e;
} else {
throw new CoreException(GeneralUtils.makeExceptionStatus(e));
}
}
}
/** 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);
}
}
}
