| /******************************************************************************* |
| * Copyright (c) 2000, 2017 IBM Corporation and others. |
| * |
| * This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License 2.0 |
| * which accompanies this distribution, and is available at |
| * https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| * Alexander Kurtakov <akurtako@redhat.com> - Bug 459343 |
| *******************************************************************************/ |
| package org.eclipse.core.tests.resources; |
| |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| import junit.framework.Test; |
| import junit.framework.TestSuite; |
| import org.eclipse.core.internal.resources.TestingSupport; |
| import org.eclipse.core.internal.resources.Workspace; |
| import org.eclipse.core.resources.*; |
| import org.eclipse.core.runtime.*; |
| import org.eclipse.core.tests.internal.resources.TestActivator; |
| import org.osgi.framework.BundleContext; |
| import org.osgi.framework.ServiceReference; |
| |
| public class IWorkspaceTest extends ResourceTest { |
| |
| public IWorkspaceTest() { |
| super(); |
| } |
| |
| public IWorkspaceTest(String name) { |
| super(name); |
| } |
| |
| @Override |
| public String[] defineHierarchy() { |
| return new String[] {"/", "/Project/", "/Project/Folder/", "/Project/Folder/File",}; |
| } |
| |
| /** |
| * Returns the nature descriptor with the given Id, or null if not found |
| */ |
| protected IProjectNatureDescriptor findNature(IProjectNatureDescriptor[] descriptors, String id) { |
| for (IProjectNatureDescriptor descriptor : descriptors) { |
| if (descriptor.getNatureId().equals(id)) { |
| return descriptor; |
| } |
| } |
| return null; |
| } |
| |
| public static Test suite() { |
| return new TestSuite(IWorkspaceTest.class); |
| // TestSuite suite = new TestSuite(); |
| // suite.addTest(new IWorkspaceTest("testValidateProjectLocation")); |
| // return suite; |
| } |
| |
| @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(); |
| } |
| |
| /** |
| * Tests handling of runnables that throw OperationCanceledException. |
| */ |
| public void testCancelRunnable() { |
| boolean cancelled = false; |
| try { |
| getWorkspace().run((IWorkspaceRunnable) monitor -> { |
| throw new OperationCanceledException(); |
| }, getMonitor()); |
| } catch (CoreException e) { |
| fail("1.0", e); |
| } catch (OperationCanceledException e) { |
| cancelled = true; |
| } |
| assertTrue("2.0", cancelled); |
| } |
| |
| /** |
| * Performs black box testing of the following method: |
| * IStatus copy([IResource, IPath, boolean, IProgressMonitor) |
| * See also testMultiCopy() |
| */ |
| public void testCopy() throws CoreException { |
| IResource[] resources = buildResources(); |
| IProject project = (IProject) resources[1]; |
| IFolder folder = (IFolder) resources[2]; |
| IFile file = (IFile) resources[3]; |
| IFile file2 = folder.getFile("File2"); |
| IFile file3 = folder.getFile("File3"); |
| IFolder folder2 = project.getFolder("Folder2"); |
| IFolder folderCopy = folder2.getFolder("Folder"); |
| IFile fileCopy = folder2.getFile("File"); |
| IFile file2Copy = folder2.getFile("File2"); |
| |
| /********** FAILURE CASES ***********/ |
| |
| //project not open |
| try { |
| getWorkspace().copy(new IResource[] {file}, folder.getFullPath(), false, getMonitor()); |
| fail("0.0"); |
| } catch (CoreException e) { |
| // should fail |
| } |
| createHierarchy(); |
| |
| //copy to bogus destination |
| try { |
| getWorkspace().copy(new IResource[] {file}, folder2.getFullPath().append("figment"), false, getMonitor()); |
| fail("1.0"); |
| } catch (CoreException e) { |
| // should fail |
| } |
| |
| //copy to non-existent destination |
| try { |
| getWorkspace().copy(new IResource[] {file}, folder2.getFullPath(), false, getMonitor()); |
| fail("1.1"); |
| } catch (CoreException e) { |
| // should fail |
| } |
| |
| //create the destination |
| try { |
| folder2.create(false, true, getMonitor()); |
| } catch (CoreException e) { |
| fail("1.2", e); |
| } |
| |
| //source file doesn't exist |
| try { |
| getWorkspace().copy(new IResource[] {file2}, folder2.getFullPath(), false, getMonitor()); |
| fail("1.3"); |
| } catch (CoreException e) { |
| // should fail |
| } |
| |
| //some source files don't exist |
| try { |
| getWorkspace().copy(new IResource[] {file, file2}, folder2.getFullPath(), false, getMonitor()); |
| fail("1.4"); |
| } catch (CoreException e) { |
| // should fail |
| } |
| |
| //make sure the first copy worked |
| assertTrue("1.5", fileCopy.exists()); |
| try { |
| fileCopy.delete(true, getMonitor()); |
| } catch (CoreException e) { |
| fail("1.6", e); |
| } |
| |
| // create the files |
| IFile projectFile = project.getFile("ProjectPhile"); |
| try { |
| file2.create(getRandomContents(), false, getMonitor()); |
| file3.create(getRandomContents(), false, getMonitor()); |
| projectFile.create(getRandomContents(), false, getMonitor()); |
| } catch (CoreException e) { |
| fail("1.7", e); |
| } |
| |
| //source files aren't siblings |
| try { |
| getWorkspace().copy(new IResource[] {file, projectFile}, folder2.getFullPath(), false, getMonitor()); |
| fail("1.8"); |
| } catch (CoreException e) { |
| // should fail |
| } |
| |
| //source files contains duplicates |
| try { |
| getWorkspace().copy(new IResource[] {file, file2, file}, folder2.getFullPath(), false, getMonitor()); |
| fail("1.9"); |
| } catch (CoreException e) { |
| // should fail |
| } |
| |
| //source can't be prefix of destination |
| try { |
| IFolder folder3 = folder2.getFolder("Folder3"); |
| folder3.create(false, true, getMonitor()); |
| getWorkspace().copy(new IResource[] {folder2}, folder3.getFullPath(), false, getMonitor()); |
| fail("2.0"); |
| } catch (CoreException e) { |
| // should fail |
| } |
| |
| //target exists |
| try { |
| file2Copy.create(getRandomContents(), false, getMonitor()); |
| getWorkspace().copy(new IResource[] {file, file2}, folder2.getFullPath(), false, getMonitor()); |
| fail("2.1"); |
| } catch (CoreException e) { |
| // should fail |
| } |
| ensureDoesNotExistInWorkspace(file2Copy); |
| ensureDoesNotExistInFileSystem(file2Copy); |
| |
| //make sure the first copy worked |
| fileCopy = folder2.getFile("File"); |
| assertTrue("2.2", fileCopy.exists()); |
| try { |
| fileCopy.delete(true, getMonitor()); |
| } catch (CoreException e) { |
| fail("2.3", e); |
| } |
| |
| //resource out of sync with filesystem |
| ensureOutOfSync(file); |
| try { |
| getWorkspace().copy(new IResource[] {file}, folder2.getFullPath(), false, getMonitor()); |
| fail("2.5"); |
| } catch (CoreException e) { |
| // should fail |
| } |
| |
| // make sure "file" is in sync. |
| file.refreshLocal(IResource.DEPTH_ZERO, null); |
| /********** NON FAILURE CASES ***********/ |
| |
| //empty resource list |
| try { |
| getWorkspace().copy(new IResource[] {}, folder2.getFullPath(), false, getMonitor()); |
| } catch (CoreException e) { |
| fail("3.0", e); |
| } catch (ArrayIndexOutOfBoundsException e) { |
| fail("Fails because of 1FTXL69", e); |
| } |
| |
| //copy single file |
| try { |
| getWorkspace().copy(new IResource[] {file}, folder2.getFullPath(), false, getMonitor()); |
| } catch (CoreException e) { |
| fail("3.1", e); |
| } |
| assertTrue("3.2", fileCopy.exists()); |
| ensureDoesNotExistInWorkspace(fileCopy); |
| ensureDoesNotExistInFileSystem(fileCopy); |
| |
| //copy two files |
| try { |
| getWorkspace().copy(new IResource[] {file, file2}, folder2.getFullPath(), false, getMonitor()); |
| } catch (CoreException e) { |
| fail("3.3", e); |
| } |
| assertTrue("3.4", fileCopy.exists()); |
| assertTrue("3.5", file2Copy.exists()); |
| ensureDoesNotExistInWorkspace(fileCopy); |
| ensureDoesNotExistInWorkspace(file2Copy); |
| ensureDoesNotExistInFileSystem(fileCopy); |
| ensureDoesNotExistInFileSystem(file2Copy); |
| |
| //copy a folder |
| try { |
| getWorkspace().copy(new IResource[] {folder}, folder2.getFullPath(), false, getMonitor()); |
| } catch (CoreException e) { |
| fail("3.6", e); |
| } |
| assertTrue("3.7", folderCopy.exists()); |
| try { |
| assertTrue("3.8", folderCopy.members().length > 0); |
| } catch (CoreException e) { |
| fail("3.9", e); |
| } |
| ensureDoesNotExistInWorkspace(folderCopy); |
| ensureDoesNotExistInFileSystem(folderCopy); |
| } |
| |
| /** |
| * Performs black box testing of the following method: |
| * IStatus delete([IResource, boolean, IProgressMonitor) |
| */ |
| public void testDelete() throws CoreException { |
| IResource[] resources = buildResources(); |
| IProject project = (IProject) resources[1]; |
| IFolder folder = (IFolder) resources[2]; |
| IFile file = (IFile) resources[3]; |
| |
| //delete non-existent resources |
| assertTrue(getWorkspace().delete(new IResource[] {project, folder, file}, false, getMonitor()).isOK()); |
| assertTrue(getWorkspace().delete(new IResource[] {file}, false, getMonitor()).isOK()); |
| assertTrue(getWorkspace().delete(new IResource[] {}, false, getMonitor()).isOK()); |
| createHierarchy(); |
| |
| //delete existing resources |
| resources = new IResource[] {file, project, folder}; |
| assertTrue(getWorkspace().delete(resources, false, getMonitor()).isOK()); |
| // assertDoesNotExistInFileSystem(resources); |
| assertDoesNotExistInWorkspace(resources); |
| createHierarchy(); |
| resources = new IResource[] {file}; |
| assertTrue(getWorkspace().delete(resources, false, getMonitor()).isOK()); |
| assertDoesNotExistInFileSystem(resources); |
| assertDoesNotExistInWorkspace(resources); |
| file.create(getRandomContents(), false, getMonitor()); |
| resources = new IResource[] {}; |
| assertTrue(getWorkspace().delete(resources, false, getMonitor()).isOK()); |
| assertDoesNotExistInFileSystem(resources); |
| assertDoesNotExistInWorkspace(resources); |
| createHierarchy(); |
| |
| //delete a combination of existing and non-existent resources |
| IProject fakeProject = getWorkspace().getRoot().getProject("pigment"); |
| IFolder fakeFolder = fakeProject.getFolder("ligament"); |
| resources = new IResource[] {file, folder, fakeFolder, project, fakeProject}; |
| assertTrue(getWorkspace().delete(resources, false, getMonitor()).isOK()); |
| // assertDoesNotExistInFileSystem(resources); |
| assertDoesNotExistInWorkspace(resources); |
| createHierarchy(); |
| resources = new IResource[] {fakeProject, file}; |
| assertTrue(getWorkspace().delete(resources, false, getMonitor()).isOK()); |
| assertDoesNotExistInFileSystem(resources); |
| assertDoesNotExistInWorkspace(resources); |
| file.create(getRandomContents(), false, getMonitor()); |
| resources = new IResource[] {fakeProject}; |
| assertTrue(getWorkspace().delete(resources, false, getMonitor()).isOK()); |
| // assertDoesNotExistInFileSystem(resources); |
| assertDoesNotExistInWorkspace(resources); |
| createHierarchy(); |
| } |
| |
| /** |
| * Performs black box testing of the following method: |
| * {@link IWorkspace#forgetSavedTree(String)}. |
| */ |
| public void testForgetSavedTree() { |
| try { |
| //according to javadoc spec, null means forget all plugin trees |
| getWorkspace().forgetSavedTree(null); |
| } catch (RuntimeException e) { |
| fail("4.99", e); |
| } |
| } |
| |
| /** |
| * Performs black box testing of the following method: |
| * IProjectNatureDescriptor[] getNatureDescriptors() |
| */ |
| public void testGetNatureDescriptors() { |
| //NOTE: see static fields for description of available test natures |
| IProjectNatureDescriptor[] descriptors = getWorkspace().getNatureDescriptors(); |
| |
| IProjectNatureDescriptor current = findNature(descriptors, NATURE_SIMPLE); |
| assertTrue("2.0", current != null); |
| assertEquals("2.1", NATURE_SIMPLE, current.getNatureId()); |
| assertEquals("2.2", "Simple", current.getLabel()); |
| assertEquals("2.3", 0, current.getRequiredNatureIds().length); |
| assertEquals("2.4", 0, current.getNatureSetIds().length); |
| |
| current = findNature(descriptors, NATURE_SNOW); |
| assertTrue("3.0", current != null); |
| assertEquals("3.1", NATURE_SNOW, current.getNatureId()); |
| assertEquals("3.2", "Snow", current.getLabel()); |
| String[] required = current.getRequiredNatureIds(); |
| assertEquals("3.3", 1, required.length); |
| assertEquals("3.4", NATURE_WATER, required[0]); |
| String[] sets = current.getNatureSetIds(); |
| assertEquals("3.5", 1, sets.length); |
| assertEquals("3.6", SET_OTHER, sets[0]); |
| |
| current = findNature(descriptors, NATURE_WATER); |
| assertTrue("4.0", current != null); |
| assertEquals("4.1", NATURE_WATER, current.getNatureId()); |
| assertEquals("4.2", "Water", current.getLabel()); |
| required = current.getRequiredNatureIds(); |
| assertEquals("4.3", 0, required.length); |
| sets = current.getNatureSetIds(); |
| assertEquals("4.4", 1, sets.length); |
| assertEquals("4.5", SET_STATE, sets[0]); |
| |
| current = findNature(descriptors, NATURE_EARTH); |
| assertTrue("5.0", current != null); |
| assertEquals("5.1", NATURE_EARTH, current.getNatureId()); |
| assertEquals("5.2", "Earth", current.getLabel()); |
| required = current.getRequiredNatureIds(); |
| assertEquals("5.3", 0, required.length); |
| sets = current.getNatureSetIds(); |
| assertEquals("5.4", 1, sets.length); |
| assertEquals("5.5", SET_STATE, sets[0]); |
| |
| current = findNature(descriptors, NATURE_MUD); |
| assertTrue("6.0", current != null); |
| assertEquals("6.1", NATURE_MUD, current.getNatureId()); |
| assertEquals("6.2", "Mud", current.getLabel()); |
| required = current.getRequiredNatureIds(); |
| assertEquals("6.3", 2, required.length); |
| //water and earth are required for mud |
| if (required[0].equals(NATURE_WATER)) { |
| assertEquals("6.4", NATURE_EARTH, required[1]); |
| } else { |
| assertEquals("6.5", NATURE_EARTH, required[0]); |
| assertEquals("6.6", NATURE_WATER, required[0]); |
| } |
| sets = current.getNatureSetIds(); |
| assertEquals("6.7", 1, sets.length); |
| assertEquals("6.8", SET_OTHER, sets[0]); |
| |
| current = findNature(descriptors, NATURE_INVALID); |
| assertTrue("7.0", current != null); |
| assertEquals("7.1", NATURE_INVALID, current.getNatureId()); |
| assertEquals("7.2", "", current.getLabel()); |
| required = current.getRequiredNatureIds(); |
| assertEquals("7.3", 0, required.length); |
| sets = current.getNatureSetIds(); |
| assertEquals("7.4", 0, sets.length); |
| |
| current = findNature(descriptors, NATURE_CYCLE1); |
| assertTrue("8.0", current != null); |
| assertEquals("8.1", NATURE_CYCLE1, current.getNatureId()); |
| assertEquals("8.2", "Cycle1", current.getLabel()); |
| required = current.getRequiredNatureIds(); |
| assertEquals("8.3", 1, required.length); |
| assertEquals("8.4", NATURE_CYCLE2, required[0]); |
| sets = current.getNatureSetIds(); |
| assertEquals("8.5", 0, sets.length); |
| |
| current = findNature(descriptors, NATURE_CYCLE2); |
| assertTrue("5.0", current != null); |
| assertEquals("9.1", NATURE_CYCLE2, current.getNatureId()); |
| assertEquals("9.2", "Cycle2", current.getLabel()); |
| required = current.getRequiredNatureIds(); |
| assertEquals("9.3", 1, required.length); |
| assertEquals("9.4", NATURE_CYCLE3, required[0]); |
| sets = current.getNatureSetIds(); |
| assertEquals("9.5", 0, sets.length); |
| |
| current = findNature(descriptors, NATURE_CYCLE3); |
| assertTrue("10.0", current != null); |
| assertEquals("10.1", NATURE_CYCLE3, current.getNatureId()); |
| assertEquals("10.2", "Cycle3", current.getLabel()); |
| required = current.getRequiredNatureIds(); |
| assertEquals("10.3", 1, required.length); |
| assertEquals("10.4", NATURE_CYCLE1, required[0]); |
| sets = current.getNatureSetIds(); |
| assertEquals("10.5", 0, sets.length); |
| } |
| |
| /** |
| * Performs black box testing of the following method: |
| * IProjectNatureDescriptor getNatureDescriptor(String) |
| */ |
| public void testGetNatureDescriptor() { |
| //NOTE: see static fields for description of available test natures |
| IWorkspace ws = getWorkspace(); |
| |
| IProjectNatureDescriptor current = ws.getNatureDescriptor(NATURE_SIMPLE); |
| assertTrue("2.0", current != null); |
| assertEquals("2.1", NATURE_SIMPLE, current.getNatureId()); |
| assertEquals("2.2", "Simple", current.getLabel()); |
| assertEquals("2.3", 0, current.getRequiredNatureIds().length); |
| assertEquals("2.4", 0, current.getNatureSetIds().length); |
| |
| current = ws.getNatureDescriptor(NATURE_SNOW); |
| assertTrue("3.0", current != null); |
| assertEquals("3.1", NATURE_SNOW, current.getNatureId()); |
| assertEquals("3.2", "Snow", current.getLabel()); |
| String[] required = current.getRequiredNatureIds(); |
| assertEquals("3.3", 1, required.length); |
| assertEquals("3.4", NATURE_WATER, required[0]); |
| String[] sets = current.getNatureSetIds(); |
| assertEquals("3.5", 1, sets.length); |
| assertEquals("3.6", SET_OTHER, sets[0]); |
| |
| current = ws.getNatureDescriptor(NATURE_WATER); |
| assertTrue("4.0", current != null); |
| assertEquals("4.1", NATURE_WATER, current.getNatureId()); |
| assertEquals("4.2", "Water", current.getLabel()); |
| required = current.getRequiredNatureIds(); |
| assertEquals("4.3", 0, required.length); |
| sets = current.getNatureSetIds(); |
| assertEquals("4.4", 1, sets.length); |
| assertEquals("4.5", SET_STATE, sets[0]); |
| |
| current = ws.getNatureDescriptor(NATURE_EARTH); |
| assertTrue("5.0", current != null); |
| assertEquals("5.1", NATURE_EARTH, current.getNatureId()); |
| assertEquals("5.2", "Earth", current.getLabel()); |
| required = current.getRequiredNatureIds(); |
| assertEquals("5.3", 0, required.length); |
| sets = current.getNatureSetIds(); |
| assertEquals("5.4", 1, sets.length); |
| assertEquals("5.5", SET_STATE, sets[0]); |
| |
| current = ws.getNatureDescriptor(NATURE_MUD); |
| assertTrue("6.0", current != null); |
| assertEquals("6.1", NATURE_MUD, current.getNatureId()); |
| assertEquals("6.2", "Mud", current.getLabel()); |
| required = current.getRequiredNatureIds(); |
| assertEquals("6.3", 2, required.length); |
| //water and earth are required for mud |
| if (required[0].equals(NATURE_WATER)) { |
| assertEquals("6.4", NATURE_EARTH, required[1]); |
| } else { |
| assertEquals("6.5", NATURE_EARTH, required[0]); |
| assertEquals("6.6", NATURE_WATER, required[0]); |
| } |
| sets = current.getNatureSetIds(); |
| assertEquals("6.7", 1, sets.length); |
| assertEquals("6.8", SET_OTHER, sets[0]); |
| |
| current = ws.getNatureDescriptor(NATURE_INVALID); |
| assertTrue("7.0", current != null); |
| assertEquals("7.1", NATURE_INVALID, current.getNatureId()); |
| assertEquals("7.2", "", current.getLabel()); |
| required = current.getRequiredNatureIds(); |
| assertEquals("7.3", 0, required.length); |
| sets = current.getNatureSetIds(); |
| assertEquals("7.4", 0, sets.length); |
| |
| current = ws.getNatureDescriptor(NATURE_CYCLE1); |
| assertTrue("8.0", current != null); |
| assertEquals("8.1", NATURE_CYCLE1, current.getNatureId()); |
| assertEquals("8.2", "Cycle1", current.getLabel()); |
| required = current.getRequiredNatureIds(); |
| assertEquals("8.3", 1, required.length); |
| assertEquals("8.4", NATURE_CYCLE2, required[0]); |
| sets = current.getNatureSetIds(); |
| assertEquals("8.5", 0, sets.length); |
| |
| current = ws.getNatureDescriptor(NATURE_CYCLE2); |
| assertTrue("5.0", current != null); |
| assertEquals("9.1", NATURE_CYCLE2, current.getNatureId()); |
| assertEquals("9.2", "Cycle2", current.getLabel()); |
| required = current.getRequiredNatureIds(); |
| assertEquals("9.3", 1, required.length); |
| assertEquals("9.4", NATURE_CYCLE3, required[0]); |
| sets = current.getNatureSetIds(); |
| assertEquals("9.5", 0, sets.length); |
| |
| current = ws.getNatureDescriptor(NATURE_CYCLE3); |
| assertTrue("10.0", current != null); |
| assertEquals("10.1", NATURE_CYCLE3, current.getNatureId()); |
| assertEquals("10.2", "Cycle3", current.getLabel()); |
| required = current.getRequiredNatureIds(); |
| assertEquals("10.3", 1, required.length); |
| assertEquals("10.4", NATURE_CYCLE1, required[0]); |
| sets = current.getNatureSetIds(); |
| assertEquals("10.5", 0, sets.length); |
| } |
| |
| /** |
| * Performs black box testing of the following method: |
| * IStatus move([IResource, IPath, boolean, IProgressMonitor) |
| */ |
| public void testMove() throws CoreException { |
| /* create folders and files */ |
| IProject project = getWorkspace().getRoot().getProject("Project"); |
| IFolder folder = project.getFolder("folder"); |
| IFile file = project.getFile("file.txt"); |
| IFile anotherFile = project.getFile("anotherFile.txt"); |
| IFile oneMoreFile = project.getFile("oneMoreFile.txt"); |
| ensureExistsInWorkspace(new IResource[] {project, folder, file, anotherFile, oneMoreFile}, true); |
| |
| /* normal case */ |
| IResource[] resources = {file, anotherFile, oneMoreFile}; |
| getWorkspace().move(resources, folder.getFullPath(), true, getMonitor()); |
| assertTrue("1.1", !file.exists()); |
| assertTrue("1.2", !anotherFile.exists()); |
| assertTrue("1.3", !oneMoreFile.exists()); |
| assertTrue("1.4", folder.getFile(file.getName()).exists()); |
| assertTrue("1.5", folder.getFile(anotherFile.getName()).exists()); |
| assertTrue("1.6", folder.getFile(oneMoreFile.getName()).exists()); |
| |
| /* test duplicates */ |
| resources = new IResource[] {folder.getFile(file.getName()), folder.getFile(anotherFile.getName()), folder.getFile(oneMoreFile.getName()), folder.getFile(oneMoreFile.getName())}; |
| IStatus status = getWorkspace().move(resources, project.getFullPath(), true, getMonitor()); |
| assertTrue("2.1", status.isOK()); |
| assertTrue("2.3", file.exists()); |
| assertTrue("2.4", anotherFile.exists()); |
| assertTrue("2.5", oneMoreFile.exists()); |
| assertTrue("2.6", !folder.getFile(file.getName()).exists()); |
| assertTrue("2.7", !folder.getFile(anotherFile.getName()).exists()); |
| assertTrue("2.8", !folder.getFile(oneMoreFile.getName()).exists()); |
| |
| /* test no simblings */ |
| resources = new IResource[] {file, anotherFile, oneMoreFile, project}; |
| boolean ok = false; |
| try { |
| getWorkspace().move(resources, folder.getFullPath(), true, getMonitor()); |
| } catch (CoreException e) { |
| ok = true; |
| status = e.getStatus(); |
| } |
| assertTrue("3.0", ok); |
| assertTrue("3.1", !status.isOK()); |
| assertTrue("3.2", status.getChildren().length == 1); |
| assertTrue("3.3", !file.exists()); |
| assertTrue("3.4", !anotherFile.exists()); |
| assertTrue("3.5", !oneMoreFile.exists()); |
| assertTrue("3.6", folder.getFile(file.getName()).exists()); |
| assertTrue("3.7", folder.getFile(anotherFile.getName()).exists()); |
| assertTrue("3.8", folder.getFile(oneMoreFile.getName()).exists()); |
| |
| /* inexisting resource */ |
| resources = new IResource[] {folder.getFile(file.getName()), folder.getFile(anotherFile.getName()), folder.getFile("inexisting"), folder.getFile(oneMoreFile.getName())}; |
| ok = false; |
| try { |
| getWorkspace().move(resources, project.getFullPath(), true, getMonitor()); |
| } catch (CoreException e) { |
| ok = true; |
| status = e.getStatus(); |
| } |
| assertTrue("4.0", ok); |
| assertTrue("4.1", !status.isOK()); |
| assertTrue("4.3", file.exists()); |
| assertTrue("4.4", anotherFile.exists()); |
| assertTrue("4.5", oneMoreFile.exists()); |
| assertTrue("4.6", !folder.getFile(file.getName()).exists()); |
| assertTrue("4.7", !folder.getFile(anotherFile.getName()).exists()); |
| assertTrue("4.8", !folder.getFile(oneMoreFile.getName()).exists()); |
| } |
| |
| /** |
| * Another test method for IWorkspace.copy(). See also testCopy |
| */ |
| public void testMultiCopy() throws CoreException { |
| /* create common objects */ |
| IResource[] resources = buildResources(); |
| IProject project = (IProject) resources[1]; |
| IFolder folder = (IFolder) resources[2]; |
| |
| /* create folder and file */ |
| ensureExistsInWorkspace(folder, true); |
| ensureExistsInFileSystem(folder); |
| IFile file1 = project.getFile("file.txt"); |
| ensureExistsInWorkspace(file1, true); |
| ensureExistsInFileSystem(file1); |
| IFile anotherFile = project.getFile("anotherFile.txt"); |
| ensureExistsInWorkspace(anotherFile, true); |
| ensureExistsInFileSystem(anotherFile); |
| IFile oneMoreFile = project.getFile("oneMoreFile.txt"); |
| ensureExistsInWorkspace(oneMoreFile, true); |
| ensureExistsInFileSystem(oneMoreFile); |
| |
| /* normal case */ |
| resources = new IResource[] {file1, anotherFile, oneMoreFile}; |
| getWorkspace().copy(resources, folder.getFullPath(), true, getMonitor()); |
| assertTrue("1.1", file1.exists()); |
| assertTrue("1.2", anotherFile.exists()); |
| assertTrue("1.3", oneMoreFile.exists()); |
| assertTrue("1.4", folder.getFile(file1.getName()).exists()); |
| assertTrue("1.5", folder.getFile(anotherFile.getName()).exists()); |
| assertTrue("1.6", folder.getFile(oneMoreFile.getName()).exists()); |
| ensureDoesNotExistInWorkspace(folder.getFile(file1.getName())); |
| ensureDoesNotExistInWorkspace(folder.getFile(anotherFile.getName())); |
| ensureDoesNotExistInWorkspace(folder.getFile(oneMoreFile.getName())); |
| ensureDoesNotExistInFileSystem(folder.getFile(file1.getName())); |
| ensureDoesNotExistInFileSystem(folder.getFile(anotherFile.getName())); |
| ensureDoesNotExistInFileSystem(folder.getFile(oneMoreFile.getName())); |
| |
| /* test duplicates */ |
| resources = new IResource[] {file1, anotherFile, oneMoreFile, file1}; |
| getWorkspace().copy(resources, folder.getFullPath(), true, getMonitor()); |
| assertTrue("2.2", file1.exists()); |
| assertTrue("2.3", anotherFile.exists()); |
| assertTrue("2.4", oneMoreFile.exists()); |
| assertTrue("2.5", folder.getFile(file1.getName()).exists()); |
| assertTrue("2.6", folder.getFile(anotherFile.getName()).exists()); |
| assertTrue("2.7", folder.getFile(oneMoreFile.getName()).exists()); |
| ensureDoesNotExistInWorkspace(folder.getFile(file1.getName())); |
| ensureDoesNotExistInWorkspace(folder.getFile(anotherFile.getName())); |
| ensureDoesNotExistInWorkspace(folder.getFile(oneMoreFile.getName())); |
| ensureDoesNotExistInFileSystem(folder.getFile(file1.getName())); |
| ensureDoesNotExistInFileSystem(folder.getFile(anotherFile.getName())); |
| ensureDoesNotExistInFileSystem(folder.getFile(oneMoreFile.getName())); |
| |
| /* test no siblings */ |
| resources = new IResource[] {file1, anotherFile, oneMoreFile, project}; |
| IStatus status = null; |
| boolean ok = false; |
| try { |
| getWorkspace().copy(resources, folder.getFullPath(), true, getMonitor()); |
| } catch (CoreException e) { |
| ok = true; |
| status = e.getStatus(); |
| } |
| assertTrue("3.0", ok); |
| assertTrue("3.1", !status.isOK()); |
| assertTrue("3.2", status.getChildren().length == 1); |
| assertTrue("3.3", file1.exists()); |
| assertTrue("3.4", anotherFile.exists()); |
| assertTrue("3.5", oneMoreFile.exists()); |
| assertTrue("3.6", folder.getFile(file1.getName()).exists()); |
| assertTrue("3.7", folder.getFile(anotherFile.getName()).exists()); |
| assertTrue("3.8", folder.getFile(oneMoreFile.getName()).exists()); |
| ensureDoesNotExistInWorkspace(folder.getFile(file1.getName())); |
| ensureDoesNotExistInWorkspace(folder.getFile(anotherFile.getName())); |
| ensureDoesNotExistInWorkspace(folder.getFile(oneMoreFile.getName())); |
| ensureDoesNotExistInFileSystem(folder.getFile(file1.getName())); |
| ensureDoesNotExistInFileSystem(folder.getFile(anotherFile.getName())); |
| ensureDoesNotExistInFileSystem(folder.getFile(oneMoreFile.getName())); |
| |
| /* inexisting resource */ |
| resources = new IResource[] {file1, anotherFile, project.getFile("inexisting"), oneMoreFile}; |
| ok = false; |
| try { |
| getWorkspace().copy(resources, folder.getFullPath(), true, getMonitor()); |
| } catch (CoreException e) { |
| ok = true; |
| status = e.getStatus(); |
| } |
| assertTrue("4.0", ok); |
| assertTrue("4.1", !status.isOK()); |
| assertTrue("4.2", file1.exists()); |
| assertTrue("4.3", anotherFile.exists()); |
| assertTrue("4.4", oneMoreFile.exists()); |
| assertTrue("4.5", folder.getFile(file1.getName()).exists()); |
| assertTrue("4.6", folder.getFile(anotherFile.getName()).exists()); |
| assertTrue("4.7 Fails because of 1FVFOOQ", folder.getFile(oneMoreFile.getName()).exists()); |
| |
| /* copy projects should not be allowed */ |
| IResource destination = getWorkspace().getRoot().getProject("destination"); |
| ok = false; |
| try { |
| getWorkspace().copy(new IResource[] {project}, destination.getFullPath(), true, getMonitor()); |
| } catch (CoreException e) { |
| ok = true; |
| status = e.getStatus(); |
| } |
| assertTrue("5.0", ok); |
| assertTrue("5.1", !status.isOK()); |
| assertTrue("5.2", status.getChildren().length == 1); |
| } |
| |
| 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 -> { |
| project.create(null); |
| 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 = getWorkspace().getRoot().getProject("testProject"); |
| 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); |
| } |
| |
| /** |
| * Test thread safety of the API method IWorkspace.setDescription. |
| */ |
| public void testMultiSetDescription() { |
| final int THREAD_COUNT = 2; |
| final CoreException[] errorPointer = new CoreException[1]; |
| Thread[] threads = new Thread[THREAD_COUNT]; |
| for (int i = 0; i < THREAD_COUNT; i++) { |
| threads[i] = new Thread((Runnable) () -> { |
| IWorkspace workspace = ResourcesPlugin.getWorkspace(); |
| IWorkspaceDescription description = workspace.getDescription(); |
| for (int j = 0; j < 100; j++) { |
| description.setAutoBuilding(false); |
| try { |
| workspace.setDescription(description); |
| } catch (CoreException e1) { |
| errorPointer[0] = e1; |
| return; |
| } |
| description.setAutoBuilding(true); |
| try { |
| workspace.setDescription(description); |
| } catch (CoreException e2) { |
| errorPointer[0] = e2; |
| return; |
| } |
| } |
| }, "Autobuild " + i); |
| threads[i].start(); |
| } |
| for (Thread thread : threads) { |
| try { |
| thread.join(); |
| } catch (InterruptedException e) { |
| } |
| } |
| if (errorPointer[0] != null) { |
| fail("1.0", errorPointer[0]); |
| } |
| } |
| |
| /** |
| * Test API method IWorkspace.setDescription. |
| */ |
| public void testSave() { |
| //ensure save returns a warning if a project's .project file is deleted. |
| IProject project = getWorkspace().getRoot().getProject("Broken"); |
| ensureExistsInWorkspace(project, true); |
| //wait for snapshot before modifying file |
| TestingSupport.waitForSnapshot(); |
| IFile descriptionFile = project.getFile(IProjectDescription.DESCRIPTION_FILE_NAME); |
| try { |
| descriptionFile.delete(IResource.NONE, null); |
| IStatus result = getWorkspace().save(true, getMonitor()); |
| assertEquals("1.0", IStatus.WARNING, result.getSeverity()); |
| } catch (CoreException e) { |
| fail("1.99", e); |
| } |
| } |
| |
| /** |
| * Performs black box testing of the following method: |
| * String[] sortNatureSet(String[]) |
| */ |
| public void testSortNatureSet() { |
| //NOTE: see static fields for description of available test natures |
| IWorkspace ws = getWorkspace(); |
| |
| //invalid sets shouldn't fail |
| String[][] invalid = getInvalidNatureSets(); |
| for (String[] element : invalid) { |
| String[] sorted = ws.sortNatureSet(element); |
| assertTrue("0.0", sorted != null); |
| //set may grow if it contained duplicates |
| assertTrue("0.1", sorted.length <= element.length); |
| } |
| String[] sorted = ws.sortNatureSet(new String[] {}); |
| assertEquals("1.0", 0, sorted.length); |
| |
| sorted = ws.sortNatureSet(new String[] {NATURE_SIMPLE}); |
| assertEquals("2.0", 1, sorted.length); |
| assertEquals("2.1", NATURE_SIMPLE, sorted[0]); |
| |
| sorted = ws.sortNatureSet(new String[] {NATURE_SNOW, NATURE_WATER}); |
| assertEquals("3.0", 2, sorted.length); |
| assertEquals("3.1", NATURE_WATER, sorted[0]); |
| assertEquals("3.2", NATURE_SNOW, sorted[1]); |
| |
| sorted = ws.sortNatureSet(new String[] {NATURE_WATER, NATURE_SIMPLE, NATURE_SNOW}); |
| assertEquals("4.0", 3, sorted.length); |
| //three valid sorts: water, snow, simple; water, simple, snow; simple, water, snow |
| boolean first = sorted[0].equals(NATURE_WATER) && sorted[1].equals(NATURE_SNOW) && sorted[2].equals(NATURE_SIMPLE); |
| boolean second = sorted[0].equals(NATURE_WATER) && sorted[1].equals(NATURE_SIMPLE) && sorted[2].equals(NATURE_SNOW); |
| boolean third = sorted[0].equals(NATURE_SIMPLE) && sorted[1].equals(NATURE_WATER) && sorted[2].equals(NATURE_SNOW); |
| assertTrue("4.1", first || second || third); |
| } |
| |
| public void testValidateEdit() { |
| // 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("MyProject"); |
| IFile file = project.getFile("myfile.txt"); |
| ensureExistsInWorkspace(new IResource[] {project, file}, true); |
| IStatus result = getWorkspace().validateEdit(new IFile[] {file}, null); |
| assertTrue("1.0", result.isOK()); |
| file.setReadOnly(true); |
| result = getWorkspace().validateEdit(new IFile[] {file}, null); |
| assertEquals("1.1", IStatus.ERROR, result.getSeverity()); |
| // assertEquals("1.2", IResourceStatus.READ_ONLY_LOCAL, result.getCode()); |
| // remove the read-only status so test cleanup will work ok |
| file.setReadOnly(false); |
| } |
| |
| public void testValidateLinkLocation() { |
| //TODO |
| //see also: some tests in LinkedResourceWithPathVariableTest |
| } |
| |
| /** |
| * Performs black box testing of the following method: |
| * IStatus validateName(String, int) |
| */ |
| public void testValidateName() { |
| /* normal name */ |
| assertTrue("1.1", getWorkspace().validateName("abcdef", IResource.FILE).isOK()); |
| /* invalid characters (windows only) */ |
| if (isWindows()) { |
| assertTrue("2.1", !getWorkspace().validateName("dsa:sf", IResource.FILE).isOK()); |
| assertTrue("2.2", !getWorkspace().validateName("*dsasf", IResource.FILE).isOK()); |
| assertTrue("2.3", !getWorkspace().validateName("?dsasf", IResource.FILE).isOK()); |
| assertTrue("2.4", !getWorkspace().validateName("\"dsasf", IResource.FILE).isOK()); |
| assertTrue("2.5", !getWorkspace().validateName("<dsasf", IResource.FILE).isOK()); |
| assertTrue("2.6", !getWorkspace().validateName(">dsasf", IResource.FILE).isOK()); |
| assertTrue("2.7", !getWorkspace().validateName("|dsasf", IResource.FILE).isOK()); |
| assertTrue("2.8", !getWorkspace().validateName("\"dsasf", IResource.FILE).isOK()); |
| assertTrue("2.10", !getWorkspace().validateName("\\dsasf", IResource.FILE).isOK()); |
| assertTrue("2.11", !getWorkspace().validateName("...", IResource.PROJECT).isOK()); |
| assertTrue("2.12", !getWorkspace().validateName("foo.", IResource.FILE).isOK()); |
| } else { |
| //trailing dots are ok on other platforms |
| assertTrue("3.3", getWorkspace().validateName("...", IResource.FILE).isOK()); |
| assertTrue("3.4", getWorkspace().validateName("....", IResource.PROJECT).isOK()); |
| assertTrue("3.7", getWorkspace().validateName("abc.", IResource.FILE).isOK()); |
| } |
| /* invalid characters on all platforms */ |
| assertTrue("2.9", !getWorkspace().validateName("/dsasf", IResource.FILE).isOK()); |
| assertTrue("2.9", !getWorkspace().validateName("", IResource.FILE).isOK()); |
| |
| /* dots */ |
| assertTrue("3.1", !getWorkspace().validateName(".", IResource.FILE).isOK()); |
| assertTrue("3.2", !getWorkspace().validateName("..", IResource.FILE).isOK()); |
| assertTrue("3.3", getWorkspace().validateName("...z", IResource.FILE).isOK()); |
| assertTrue("3.4", getWorkspace().validateName("....z", IResource.FILE).isOK()); |
| assertTrue("3.5", getWorkspace().validateName("....abc", IResource.FILE).isOK()); |
| assertTrue("3.6", getWorkspace().validateName("abc....def", IResource.FILE).isOK()); |
| assertTrue("3.7", getWorkspace().validateName("abc.d...z", IResource.FILE).isOK()); |
| } |
| |
| /** |
| * Performs black box testing of the following method: |
| * IStatus validateNatureSet(String[]) |
| */ |
| public void testValidateNatureSet() { |
| //NOTE: see static fields for description of available test natures |
| IWorkspace ws = getWorkspace(); |
| |
| String[][] invalid = getInvalidNatureSets(); |
| for (int i = 0; i < invalid.length; i++) { |
| IStatus result = ws.validateNatureSet(invalid[i]); |
| assertTrue("invalid (severity): " + i, !result.isOK()); |
| assertTrue("invalid (code): " + i, result.getCode() != IStatus.OK); |
| } |
| String[][] valid = getValidNatureSets(); |
| for (int i = 0; i < valid.length; i++) { |
| IStatus result = ws.validateNatureSet(valid[i]); |
| assertTrue("valid (severity): " + i, result.isOK()); |
| assertTrue("valid (code): " + i, result.getCode() == IStatus.OK); |
| } |
| } |
| |
| /** |
| * Performs black box testing of the following method: |
| * IStatus validatePath(String, int) |
| */ |
| public void testValidatePath() { |
| /* normal path */ |
| assertTrue("1.1", getWorkspace().validatePath("/one/two/three/four/", IResource.FILE | IResource.FOLDER).isOK()); |
| |
| /* invalid characters (windows only) */ |
| final boolean WINDOWS = isWindows(); |
| if (WINDOWS) { |
| assertTrue("2.1", !(getWorkspace().validatePath("\\dsa:sf", IResource.FILE).isOK())); |
| assertTrue("2.2", !(getWorkspace().validatePath("/abc/*dsasf", IResource.FILE).isOK())); |
| assertTrue("2.3", !(getWorkspace().validatePath("/abc/?dsasf", IResource.FILE).isOK())); |
| assertTrue("2.4", !(getWorkspace().validatePath("/abc/\"dsasf", IResource.FILE).isOK())); |
| assertTrue("2.5", !(getWorkspace().validatePath("/abc/<dsasf", IResource.FILE).isOK())); |
| assertTrue("2.6", !(getWorkspace().validatePath("/abc/>dsasf", IResource.FILE).isOK())); |
| assertTrue("2.7", !(getWorkspace().validatePath("/abc/|dsasf", IResource.FILE).isOK())); |
| assertTrue("2.8", !(getWorkspace().validatePath("/abc/\"dsasf", IResource.FILE).isOK())); |
| |
| assertTrue("5.2", !(getWorkspace().validatePath("\\", IResource.FILE).isOK())); |
| assertTrue("5.4", !(getWorkspace().validatePath("device:/abc/123", IResource.FILE).isOK())); |
| |
| //trailing dots in segments names not allowed on Windows |
| assertTrue("3.1", !getWorkspace().validatePath("/abc/.../defghi", IResource.FILE).isOK()); |
| assertTrue("3.2", !getWorkspace().validatePath("/abc/..../defghi", IResource.FILE).isOK()); |
| assertTrue("3.3", !getWorkspace().validatePath("/abc/def..../ghi", IResource.FILE).isOK()); |
| } else { |
| assertTrue("3.1", getWorkspace().validatePath("/abc/.../defghi", IResource.FILE).isOK()); |
| assertTrue("3.2", getWorkspace().validatePath("/abc/..../defghi", IResource.FILE).isOK()); |
| assertTrue("3.3", getWorkspace().validatePath("/abc/def..../ghi", IResource.FILE).isOK()); |
| } |
| |
| /* dots */ |
| assertTrue("3.4", getWorkspace().validatePath("/abc/../ghi/j", IResource.FILE).isOK()); |
| assertTrue("3.5", getWorkspace().validatePath("/abc/....def/ghi", IResource.FILE).isOK()); |
| assertTrue("3.6", getWorkspace().validatePath("/abc/def....ghi/jkl", IResource.FILE).isOK()); |
| |
| /* test hiding incorrect characters using .. and device separator : */ |
| assertTrue("4.1", getWorkspace().validatePath("/abc/.?./../def/as", IResource.FILE).isOK()); |
| assertTrue("4.2", getWorkspace().validatePath("/abc/;*?\"'/../def/safd", IResource.FILE).isOK()); |
| assertTrue("4.3", getWorkspace().validatePath("/abc;*?\"':/def/asdf/sadf", IResource.FILE).isOK() != WINDOWS); |
| |
| /* other invalid paths */ |
| assertTrue("5.1", !(getWorkspace().validatePath("/", IResource.FILE).isOK())); |
| assertTrue("5.3", !(getWorkspace().validatePath("", IResource.FILE).isOK())); |
| |
| /* test types / segments */ |
| assertTrue("6.6", getWorkspace().validatePath("/asf", IResource.PROJECT).isOK()); |
| assertTrue("6.7", !(getWorkspace().validatePath("/asf", IResource.FILE).isOK())); |
| // note this is value for a file OR project (note the logical OR) |
| assertTrue("6.8", getWorkspace().validatePath("/asf", IResource.PROJECT | IResource.FILE).isOK()); |
| assertTrue("6.10", getWorkspace().validatePath("/project/.metadata", IResource.FILE).isOK()); |
| // FIXME: Should this be valid? |
| assertTrue("6.11", getWorkspace().validatePath("/.metadata/project", IResource.FILE).isOK()); |
| } |
| |
| /** |
| * Performs black box testing of the following method: |
| * IStatus validateProjectLocation(IProject, IPath) |
| */ |
| public void testValidateProjectLocation() { |
| IWorkspace workspace = getWorkspace(); |
| IProject project = workspace.getRoot().getProject("Project"); |
| |
| /* normal path */ |
| assertTrue("1.1", workspace.validateProjectLocation(project, new Path("/one/two/three/four/")).isOK()); |
| |
| /* invalid characters (windows only) */ |
| final boolean WINDOWS = isWindows(); |
| if (WINDOWS) { |
| assertTrue("2.1", !workspace.validateProjectLocation(project, new Path("d:\\dsa:sf")).isOK()); |
| assertTrue("2.2", !workspace.validateProjectLocation(project, new Path("/abc/*dsasf")).isOK()); |
| assertTrue("2.3", !workspace.validateProjectLocation(project, new Path("/abc/?dsasf")).isOK()); |
| assertTrue("2.4", !workspace.validateProjectLocation(project, new Path("/abc/\"dsasf")).isOK()); |
| assertTrue("2.5", !workspace.validateProjectLocation(project, new Path("/abc/<dsasf")).isOK()); |
| assertTrue("2.6", !workspace.validateProjectLocation(project, new Path("/abc/>dsasf")).isOK()); |
| assertTrue("2.7", !workspace.validateProjectLocation(project, new Path("/abc/|dsasf")).isOK()); |
| assertTrue("2.8", !workspace.validateProjectLocation(project, new Path("/abc/\"dsasf")).isOK()); |
| |
| //trailing dots invalid on Windows |
| assertTrue("3.1", !workspace.validateProjectLocation(project, new Path("/abc/.../defghi")).isOK()); |
| assertTrue("3.2", !workspace.validateProjectLocation(project, new Path("/abc/..../defghi")).isOK()); |
| assertTrue("3.3", !workspace.validateProjectLocation(project, new Path("/abc/def..../ghi")).isOK()); |
| } else { |
| assertTrue("3.1", workspace.validateProjectLocation(project, new Path("/abc/.../defghi")).isOK()); |
| assertTrue("3.2", workspace.validateProjectLocation(project, new Path("/abc/..../defghi")).isOK()); |
| assertTrue("3.3", workspace.validateProjectLocation(project, new Path("/abc/def..../ghi")).isOK()); |
| } |
| |
| /* dots */ |
| assertTrue("3.4", workspace.validateProjectLocation(project, new Path("/abc/....def/ghi")).isOK()); |
| assertTrue("3.5", workspace.validateProjectLocation(project, new Path("/abc/def....ghi/jkl")).isOK()); |
| |
| /* test hiding incorrect characters using .. and device separator : */ |
| assertTrue("4.1", workspace.validateProjectLocation(project, new Path("/abc/.?./../def/as")).isOK()); |
| assertTrue("4.2", workspace.validateProjectLocation(project, new Path("/abc/;*?\"'/../def/safd")).isOK()); |
| assertTrue("4.3", !(workspace.validateProjectLocation(project, new Path("c:/abc;*?\"':/def/asdf/sadf")).isOK())); |
| |
| // cannot overlap the platform directory |
| IPath platformLocation = Platform.getLocation(); |
| assertTrue("5.1", !(workspace.validateProjectLocation(project, new Path(platformLocation.getDevice(), "/")).isOK())); |
| assertTrue("5.2", !(workspace.validateProjectLocation(project, new Path(platformLocation.getDevice(), "\\")).isOK())); |
| assertTrue("5.3", !(workspace.validateProjectLocation(project, new Path(platformLocation.getDevice(), "")).isOK())); |
| assertTrue("5.4", !(workspace.validateProjectLocation(project, platformLocation).isOK())); |
| assertTrue("5.5", !(workspace.validateProjectLocation(project, platformLocation.append("foo")).isOK())); |
| |
| //can overlap platform directory on another device |
| IPath anotherDevice = platformLocation.setDevice("u:"); |
| assertTrue("6.1", workspace.validateProjectLocation(project, new Path("u:", "/")).isOK()); |
| if (WINDOWS) { |
| assertTrue("6.2", workspace.validateProjectLocation(project, new Path("u:", "\\")).isOK()); |
| } |
| assertTrue("6.4", workspace.validateProjectLocation(project, anotherDevice).isOK()); |
| assertTrue("6.5", workspace.validateProjectLocation(project, anotherDevice.append("foo")).isOK()); |
| |
| //cannot be a relative path |
| assertTrue("7.1", !workspace.validateProjectLocation(project, new Path("u:", "")).isOK()); |
| assertTrue("7.2", !workspace.validateProjectLocation(project, new Path("c:")).isOK()); |
| assertTrue("7.3", !workspace.validateProjectLocation(project, new Path("c:foo")).isOK()); |
| assertTrue("7.4", !workspace.validateProjectLocation(project, new Path("foo/bar")).isOK()); |
| assertTrue("7.5", !workspace.validateProjectLocation(project, new Path("c:foo/bar")).isOK()); |
| |
| //may be relative to an existing path variable |
| final String PATH_VAR_NAME = "FOOVAR"; |
| final IPath PATH_VAR_VALUE = getRandomLocation(); |
| try { |
| try { |
| IPath varPath = new Path(PATH_VAR_NAME); |
| workspace.getPathVariableManager().setValue(PATH_VAR_NAME, PATH_VAR_VALUE); |
| assertTrue("8.1", workspace.validateProjectLocation(project, varPath).isOK()); |
| assertTrue("8.2", workspace.validateProjectLocation(project, varPath.append("test")).isOK()); |
| assertTrue("8.3", workspace.validateProjectLocation(project, varPath.append("test/ing")).isOK()); |
| } finally { |
| workspace.getPathVariableManager().setValue(PATH_VAR_NAME, null); |
| } |
| } catch (CoreException e) { |
| fail("8.99", e); |
| } |
| |
| //cannot overlap with another project's location |
| IPath openProjectLocation = getTempDir().append("OpenProject"); |
| IProject open = workspace.getRoot().getProject("OpenProject"); |
| IProjectDescription openDesc = workspace.newProjectDescription(open.getName()); |
| openDesc.setLocation(openProjectLocation); |
| IPath closedProjectLocation = getTempDir().append("ClosedProject"); |
| IProject closed = workspace.getRoot().getProject("ClosedProject"); |
| IProjectDescription closedDesc = workspace.newProjectDescription(closed.getName()); |
| closedDesc.setLocation(closedProjectLocation); |
| try { |
| open.create(openDesc, null); |
| open.open(null); |
| closed.create(closedDesc, null); |
| } catch (CoreException e) { |
| fail("9.99", e); |
| } |
| IPath linkLocation = getRandomLocation(); |
| try { |
| //indirect test: setting the project description may validate location, which shouldn't complain |
| IProjectDescription desc = open.getDescription(); |
| desc.setReferencedProjects(new IProject[] {project}); |
| open.setDescription(desc, IResource.FORCE, getMonitor()); |
| |
| assertTrue("9.1", !workspace.validateProjectLocation(project, openProjectLocation).isOK()); |
| assertTrue("9.2", !workspace.validateProjectLocation(project, closedProjectLocation).isOK()); |
| |
| //for an existing project, it cannot overlap itself, but its own location is valid |
| assertTrue("9.3", workspace.validateProjectLocation(open, openProjectLocation).isOK()); |
| assertTrue("9.4", !workspace.validateProjectLocation(open, openProjectLocation.append("sub")).isOK()); |
| |
| //an existing project cannot overlap the location of any linked resource in that project |
| linkLocation.toFile().mkdirs(); |
| assertTrue("10.1", workspace.validateProjectLocation(open, linkLocation).isOK()); |
| IFolder link = open.getFolder("link"); |
| link.createLink(linkLocation, IResource.NONE, getMonitor()); |
| assertTrue("10.2", !workspace.validateProjectLocation(open, linkLocation).isOK()); |
| assertTrue("10.3", !workspace.validateProjectLocation(open, linkLocation.append("sub")).isOK()); |
| |
| //however another project can overlap an existing link location |
| assertTrue("10.4", workspace.validateProjectLocation(project, linkLocation).isOK()); |
| |
| // A new project cannot overlap the default locations of other projects, but its own location is valid |
| IPath defaultProjectLocation = workspace.getRoot().getLocation(); |
| assertTrue("11.1", workspace.validateProjectLocation(project, defaultProjectLocation.append(project.getName())).isOK()); |
| assertTrue("11.2", !workspace.validateProjectLocation(project, defaultProjectLocation.append("foo")).isOK()); |
| } catch (CoreException e) { |
| fail("11.99", e); |
| } finally { |
| Workspace.clear(linkLocation.toFile()); |
| //make sure we clean up project directories |
| try { |
| open.delete(IResource.ALWAYS_DELETE_PROJECT_CONTENT, getMonitor()); |
| open.delete(IResource.ALWAYS_DELETE_PROJECT_CONTENT, getMonitor()); |
| } catch (CoreException e) { |
| } |
| ensureDoesNotExistInFileSystem(openProjectLocation.toFile()); |
| ensureDoesNotExistInFileSystem(closedProjectLocation.toFile()); |
| } |
| |
| // cannot overlap .metadata folder from the current workspace |
| assertTrue("12.1", !(workspace.validateProjectLocation(project, platformLocation.addTrailingSeparator().append(".metadata"))).isOK()); |
| |
| IProject metadataProject = workspace.getRoot().getProject(".metadata"); |
| assertTrue("12.2", !(workspace.validateProjectLocation(metadataProject, null)).isOK()); |
| |
| // FIXME: Should this be valid? |
| assertTrue("23.1", workspace.validateProjectLocation(project, new Path("/asf")).isOK()); |
| assertTrue("23.2", workspace.validateProjectLocation(project, new Path("/project/.metadata")).isOK()); |
| // FIXME: Should this be valid? |
| assertTrue("23.3", workspace.validateProjectLocation(project, new Path("/.metadata/project")).isOK()); |
| } |
| |
| /** |
| * Performs black box testing of the following method: |
| * IStatus validateProjectLocationURI(IProject, URI) |
| */ |
| public void testValidateProjectLocationURI() { |
| IWorkspace workspace = getWorkspace(); |
| IProject project = workspace.getRoot().getProject("Project"); |
| try { |
| //URI with no scheme |
| URI uri = new URI("eferfsdfwer"); |
| assertTrue("1.0", !workspace.validateProjectLocationURI(project, uri).isOK()); |
| //URI with unknown scheme |
| uri = new URI("blorts://foo.com?bad"); |
| assertTrue("1.1", !workspace.validateProjectLocationURI(project, uri).isOK()); |
| } catch (URISyntaxException e) { |
| fail("1.99", e); |
| } |
| } |
| |
| public void testWorkspaceService() { |
| final BundleContext context = TestActivator.getContext(); |
| ServiceReference<IWorkspace> ref = context.getServiceReference(IWorkspace.class); |
| assertNotNull("1.0", ref); |
| IWorkspace ws = context.getService(ref); |
| assertNotNull("1.1", ws); |
| } |
| |
| public void testGetFilterMatcherDescriptor() { |
| IFilterMatcherDescriptor descriptor = getWorkspace().getFilterMatcherDescriptor(""); |
| assertNull("1.0", descriptor); |
| descriptor = getWorkspace().getFilterMatcherDescriptor("org.eclipse.core.resources.regexFilterMatcher"); |
| assertNotNull("1.1", descriptor); |
| } |
| } |