| /******************************************************************************* |
| * Copyright (c) 2000, 2017 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| * James Blackburn (Broadcom Corp.) - ongoing development |
| *******************************************************************************/ |
| package org.eclipse.core.tests.internal.alias; |
| |
| import java.net.URI; |
| import java.util.Arrays; |
| import junit.framework.Test; |
| import junit.framework.TestSuite; |
| import org.eclipse.core.filesystem.EFS; |
| import org.eclipse.core.filesystem.IFileStore; |
| import org.eclipse.core.internal.resources.*; |
| import org.eclipse.core.resources.*; |
| import org.eclipse.core.runtime.*; |
| import org.eclipse.core.tests.internal.filesystem.wrapper.WrapperFileSystem; |
| import org.eclipse.core.tests.resources.ResourceTest; |
| |
| /** |
| * Tests basic API methods in the face of aliased resources, and ensures that |
| * nothing is ever out of sync. |
| */ |
| public class BasicAliasTest extends ResourceTest { |
| //resource handles (p=project, f=folder, l=file) |
| private IProject pNoOverlap; |
| private IProject pOverlap; |
| private IProject pLinked; |
| private IFolder fOverlap; |
| private IFile lChildOverlap; |
| private IFile lOverlap; |
| private IFolder fLinked; |
| private IFolder fLinkOverlap1; |
| private IFolder fLinkOverlap2; |
| private IFile lLinked; |
| private IFile lChildLinked; |
| private IPath linkOverlapLocation; |
| |
| public static Test suite() { |
| return new TestSuite(BasicAliasTest.class); |
| |
| // TestSuite suite = new TestSuite(); |
| // suite.addTest(new BasicAliasTest("testDeepLink")); |
| // suite.addTest(new BasicAliasTest("testCreateDeleteLink")); |
| // return suite; |
| } |
| |
| public BasicAliasTest() { |
| super(); |
| } |
| |
| public BasicAliasTest(String name) { |
| super(name); |
| } |
| |
| /** |
| * Asserts that the two given resources are duplicates in the file system. |
| * Asserts that both have same location, and same members. Also asserts |
| * that both resources are in sync with the file system. The resource names |
| * in the tree may be different. The resources may not necessarily exist. |
| */ |
| public void assertOverlap(String message, IResource resource1, IResource resource2) { |
| String errMsg = message + resource1.getFullPath().toString(); |
| assertEquals(errMsg + "(location)", resource1.getLocation(), resource2.getLocation()); |
| assertTrue(errMsg + "(sync)", resource1.isSynchronized(IResource.DEPTH_ZERO)); |
| assertTrue(errMsg + "(sync)", resource2.isSynchronized(IResource.DEPTH_ZERO)); |
| |
| IResource[] children1 = null; |
| IResource[] children2 = null; |
| try { |
| children1 = getSortedChildren(resource1); |
| children2 = getSortedChildren(resource2); |
| } catch (CoreException e) { |
| fail(errMsg, e); |
| } |
| assertEquals(errMsg + "(child count)", children1.length, children2.length); |
| for (int i = 0; i < children2.length; i++) { |
| assertOverlap(message, children1[i], children2[i]); |
| } |
| } |
| |
| /** |
| * Returns the children of the given resource, sorted in a consistent |
| * alphabetical order. |
| */ |
| private IResource[] getSortedChildren(IResource resource) throws CoreException { |
| if (!(resource instanceof IContainer)) { |
| return new IResource[0]; |
| } |
| IResource[] children = ((IContainer) resource).members(); |
| Arrays.sort(children, (arg0, arg1) -> arg0.getFullPath().toString().compareTo(arg1.getFullPath().toString())); |
| return children; |
| } |
| |
| @Override |
| protected void setUp() throws Exception { |
| super.setUp(); |
| IWorkspaceRoot root = getWorkspace().getRoot(); |
| //project with no overlap |
| pNoOverlap = root.getProject("NoOverlap"); |
| ensureExistsInWorkspace(pNoOverlap, true); |
| ensureExistsInWorkspace(buildResources(pNoOverlap, new String[] {"/1/", "/1/1", "/1/2", "/2/", "/2/1"}), true); |
| |
| //project with overlap |
| pOverlap = root.getProject("Overlap"); |
| ensureExistsInWorkspace(pOverlap, true); |
| fOverlap = pOverlap.getFolder("fOverlap"); |
| IFolder f2 = pOverlap.getFolder("F2"); |
| lOverlap = f2.getFile("lOverlap"); |
| lChildOverlap = fOverlap.getFile("lChildOverlap"); |
| ensureExistsInWorkspace(new IResource[] {fOverlap, f2, lOverlap, lChildOverlap}, true); |
| //create some other random child elements |
| ensureExistsInWorkspace(buildResources(pOverlap, new String[] {"/1/", "/1/1", "/1/2"}), true); |
| ensureExistsInWorkspace(buildResources(f2, new String[] {"/1/", "/1/1", "/1/2"}), true); |
| ensureExistsInWorkspace(buildResources(fOverlap, new String[] {"/1/", "/1/1", "/1/2"}), true); |
| |
| //create links |
| pLinked = root.getProject("LinkProject"); |
| ensureExistsInWorkspace(pLinked, true); |
| fLinked = pLinked.getFolder("LinkedFolder"); |
| fLinkOverlap1 = pLinked.getFolder("LinkOverlap1"); |
| fLinkOverlap2 = pLinked.getFolder("LinkOverlap2"); |
| lLinked = pLinked.getFile("LinkedFile"); |
| lChildLinked = fLinked.getFile(lChildOverlap.getName()); |
| fLinked.createLink(fOverlap.getLocation(), IResource.NONE, null); |
| lLinked.createLink(lOverlap.getLocation(), IResource.NONE, null); |
| ensureExistsInWorkspace(lChildLinked, true); |
| ensureExistsInWorkspace(buildResources(pLinked, new String[] {"/a/", "/a/a", "/a/b"}), true); |
| ensureExistsInWorkspace(buildResources(fLinked, new String[] {"/a/", "/a/a", "/a/b"}), true); |
| |
| linkOverlapLocation = getRandomLocation(); |
| linkOverlapLocation.toFile().mkdirs(); |
| fLinkOverlap1.createLink(linkOverlapLocation, IResource.NONE, null); |
| fLinkOverlap2.createLink(linkOverlapLocation, IResource.NONE, null); |
| } |
| |
| @Override |
| protected void tearDown() throws Exception { |
| super.tearDown(); |
| Workspace.clear(linkOverlapLocation.toFile()); |
| } |
| |
| /** |
| * This tests regression of bug 32785. In this bug, moving a linked folder, |
| * then copying a linked folder, resulted in the alias table having a stale entry |
| */ |
| public void testBug32785() { |
| IProject project = pNoOverlap; |
| IFolder link = project.getFolder("Source"); |
| IFile child = link.getFile("Child.txt"); |
| IPath location = getRandomLocation(); |
| location.toFile().mkdirs(); |
| try { |
| try { |
| link.createLink(location, IResource.NONE, getMonitor()); |
| ensureExistsInWorkspace(child, getRandomContents()); |
| } catch (CoreException e) { |
| fail("1.99", e); |
| } |
| //move the link (rename) |
| IFolder movedLink = project.getFolder("MovedLink"); |
| try { |
| link.move(movedLink.getFullPath(), IResource.SHALLOW, getMonitor()); |
| } catch (CoreException e) { |
| fail("2.99", e); |
| } |
| assertTrue("3.0", !link.exists()); |
| assertTrue("3.1", movedLink.exists()); |
| assertEquals("3.2", location, movedLink.getLocation()); |
| assertTrue("3.3", movedLink.isSynchronized(IResource.DEPTH_INFINITE)); |
| |
| //now copy the moved link |
| IFolder copiedLink = project.getFolder("CopiedLink"); |
| try { |
| movedLink.copy(copiedLink.getFullPath(), IResource.SHALLOW, getMonitor()); |
| } catch (CoreException e) { |
| fail("3.99", e); |
| } |
| assertTrue("4.0", !link.exists()); |
| assertTrue("4.1", movedLink.exists()); |
| assertTrue("4.2", copiedLink.exists()); |
| assertEquals("4.3", location, movedLink.getLocation()); |
| assertEquals("4.4", location, copiedLink.getLocation()); |
| assertTrue("4.5", movedLink.isSynchronized(IResource.DEPTH_INFINITE)); |
| assertTrue("4.6", copiedLink.isSynchronized(IResource.DEPTH_INFINITE)); |
| } finally { |
| Workspace.clear(location.toFile()); |
| } |
| } |
| |
| /** |
| * Regression test for bug 156082. A project has aliases to multiple |
| * other projects, but the other projects don't overlap each other. I.e., |
| * Project Top overlaps Sub1 and Sub2, but Sub1 and Sub2 do not overlap each other. |
| */ |
| public void testBug156082() { |
| IProject top = getWorkspace().getRoot().getProject("Bug156082_Top"); |
| IProject sub1 = getWorkspace().getRoot().getProject("Bug156082_Sub1"); |
| IProject sub2 = getWorkspace().getRoot().getProject("Bug156082_Sub2"); |
| ensureExistsInWorkspace(top, true); |
| IProjectDescription desc1 = getWorkspace().newProjectDescription(sub1.getName()); |
| desc1.setLocation(top.getLocation().append(sub1.getName())); |
| IProjectDescription desc2 = getWorkspace().newProjectDescription(sub2.getName()); |
| desc2.setLocation(top.getLocation().append(sub2.getName())); |
| try { |
| sub1.create(desc1, getMonitor()); |
| sub1.open(getMonitor()); |
| sub2.create(desc2, getMonitor()); |
| sub2.open(getMonitor()); |
| } catch (CoreException e) { |
| fail("0.99", e); |
| } |
| IFile sub2File = sub2.getFile("file.txt"); |
| IFile topFile = top.getFolder(sub2.getName()).getFile(sub2File.getName()); |
| ensureExistsInWorkspace(sub2File, getRandomContents()); |
| assertTrue("1.0", topFile.exists()); |
| } |
| |
| /** |
| * Regression test for bug 198571. Device ids should be respected by the comparator |
| * used in the locations map of AliasManager. |
| */ |
| public void testBug198571() { |
| if (!isWindows()) { |
| return; |
| } |
| |
| /* look for the adequate environment */ |
| String[] devices = findAvailableDevices(); |
| if (devices[0] == null || devices[1] == null) { |
| return; |
| } |
| |
| String location = getUniqueString(); |
| IProject testProject1 = getWorkspace().getRoot().getProject(location + "1"); |
| IProject testProject2 = getWorkspace().getRoot().getProject(location + "2"); |
| |
| // the projects have the same segments but different id |
| IProjectDescription desc1 = getWorkspace().newProjectDescription(testProject1.getName()); |
| IPath location1 = new Path(devices[0] + location); |
| assertTrue("0.1", !location1.toFile().exists()); |
| desc1.setLocation(location1); |
| IProjectDescription desc2 = getWorkspace().newProjectDescription(testProject2.getName()); |
| IPath location2 = new Path(devices[1] + location); |
| assertTrue("0.2", !location2.toFile().exists()); |
| desc2.setLocation(location2); |
| |
| try { |
| try { |
| testProject1.create(desc1, getMonitor()); |
| testProject1.open(getMonitor()); |
| testProject2.create(desc2, getMonitor()); |
| testProject2.open(getMonitor()); |
| } catch (CoreException e) { |
| fail("1.0", e); |
| } |
| |
| final AliasManager aliasManager = ((Workspace) getWorkspace()).getAliasManager(); |
| //force AliasManager to restart (simulates a shutdown/startup) |
| aliasManager.startup(null); |
| |
| // new folder in one of the projects |
| IFolder folder = testProject2.getFolder("NewFolder"); |
| ensureExistsInFileSystem(folder); |
| |
| try { |
| testProject2.refreshLocal(IResource.DEPTH_INFINITE, null); |
| IResource[] resources = aliasManager.computeAliases(folder, ((Folder) folder).getStore()); |
| assertNull(resources); |
| } catch (CoreException e) { |
| fail("2.0", e); |
| } |
| } finally { |
| //make sure we don't leave behind a mess on the test machine |
| clear(EFS.getLocalFileSystem().getStore(location1)); |
| clear(EFS.getLocalFileSystem().getStore(location2)); |
| } |
| } |
| |
| private void replaceProject(IProject project, URI newLocation) throws CoreException { |
| IProjectDescription projectDesc = project.getDescription(); |
| projectDesc.setLocationURI(newLocation); |
| project.move(projectDesc, IResource.REPLACE, null); |
| } |
| |
| public void testBug256837() { |
| final AliasManager aliasManager = ((Workspace) getWorkspace()).getAliasManager(); |
| //force AliasManager to restart (simulates a shutdown/startup) |
| aliasManager.startup(null); |
| |
| IWorkspaceRoot root = getWorkspace().getRoot(); |
| IProject p1 = root.getProject(getUniqueString()); |
| IProject p2 = root.getProject(getUniqueString()); |
| ensureExistsInWorkspace(new IResource[] {p1, p2}, true); |
| |
| IFileStore tempStore = null; |
| try { |
| tempStore = getTempStore(); |
| tempStore.mkdir(EFS.NONE, getMonitor()); |
| } catch (CoreException e1) { |
| fail("1.0", e1); |
| } |
| |
| try { |
| replaceProject(p2, WrapperFileSystem.getWrappedURI(p2.getLocationURI())); |
| } catch (CoreException e) { |
| fail("2.0", e); |
| } |
| |
| IFolder link2TempFolder = p1.getFolder("link2TempFolder"); |
| try { |
| link2TempFolder.createLink(tempStore.toURI(), IResource.NONE, getMonitor()); |
| } catch (CoreException e) { |
| fail("3.0", e); |
| } |
| |
| // change the location of p2 project to the temp folder |
| try { |
| replaceProject(p2, tempStore.toURI()); |
| } catch (CoreException e) { |
| fail("4.0", e); |
| } |
| |
| // now p2 and link2TempFolder should be aliases |
| IResource[] resources = aliasManager.computeAliases(link2TempFolder, ((Folder) link2TempFolder).getStore()); |
| assertEquals("5.0", 1, resources.length); |
| assertEquals("6.0", p2, resources[0]); |
| |
| resources = aliasManager.computeAliases(p2, ((Project) p2).getStore()); |
| assertEquals("7.0", 1, resources.length); |
| assertEquals("8.0", link2TempFolder, resources[0]); |
| } |
| |
| public void testBug258987() { |
| // Create the directory to which you will link. The directory needs a single file. |
| IFileStore dirStore = getTempStore(); |
| try { |
| dirStore.mkdir(EFS.NONE, getMonitor()); |
| } catch (CoreException e) { |
| fail("1.0", e); |
| } |
| assertTrue("2.0", dirStore.fetchInfo().exists()); |
| assertTrue("3.0", dirStore.fetchInfo().isDirectory()); |
| |
| IFileStore childStore = dirStore.getChild("child"); |
| createFileInFileSystem(childStore); |
| assertTrue("4.0", childStore.fetchInfo().exists()); |
| |
| // Create and open the first project. Project links to the directory. |
| IProject project1 = ResourcesPlugin.getWorkspace().getRoot().getProject("project1"); |
| IFolder folder1 = null; |
| try { |
| project1.create(getMonitor()); |
| project1.open(getMonitor()); |
| folder1 = project1.getFolder("subdir"); |
| folder1.createLink(dirStore.toURI(), IResource.REPLACE, getMonitor()); |
| } catch (CoreException e) { |
| fail("5.0", e); |
| } |
| |
| // Create and open the second project. It also links to the directory. |
| IProject project2 = ResourcesPlugin.getWorkspace().getRoot().getProject("project2"); |
| IFolder folder2 = null; |
| try { |
| project2.create(getMonitor()); |
| project2.open(getMonitor()); |
| folder2 = project2.getFolder("subdir"); |
| folder2.createLink(dirStore.toURI(), IResource.REPLACE, getMonitor()); |
| } catch (CoreException e) { |
| fail("6.0", e); |
| } |
| |
| // Close the second project. |
| try { |
| project2.close(getMonitor()); |
| } catch (CoreException e) { |
| fail("7.0", e); |
| } |
| |
| // Since project2 is closed, folder2 should not be an alias for folder1 anymore |
| IResource[] resources = ((Workspace) getWorkspace()).getAliasManager().computeAliases(folder1, ((Folder) folder1).getStore()); |
| assertNull("8.0", resources); |
| } |
| |
| public void testCloseOpenProject() { |
| //close the project and make sure aliases in that project are no longer updated |
| try { |
| pOverlap.close(getMonitor()); |
| IFile linkFile = fLinked.getFile("ChildFile.txt"); |
| linkFile.create(getRandomContents(), IResource.NONE, getMonitor()); |
| IFile closedFile = fOverlap.getFile(linkFile.getName()); |
| assertTrue("1.0", !closedFile.exists()); |
| pOverlap.open(IResource.NONE, getMonitor()); |
| //should a refresh be needed when a project has been changed while it was closed? |
| pOverlap.refreshLocal(IResource.DEPTH_INFINITE, getMonitor()); |
| assertTrue("1.1", closedFile.exists()); |
| } catch (CoreException e) { |
| fail("4.99", e); |
| } |
| } |
| |
| /** |
| * Tests adding a file to a duplicate region by copying. |
| */ |
| public void testCopyFile() { |
| IFile sourceFile = pNoOverlap.getFile("CopySource"); |
| ensureExistsInWorkspace(sourceFile, true); |
| |
| //file in linked folder |
| try { |
| IFile linkDest = fLinked.getFile("CopyDestination"); |
| IFile overlapDest = fOverlap.getFile(linkDest.getName()); |
| |
| sourceFile.copy(linkDest.getFullPath(), IResource.NONE, getMonitor()); |
| assertTrue("1.1", linkDest.exists()); |
| assertTrue("1.2", overlapDest.exists()); |
| assertOverlap("1.3", linkDest, overlapDest); |
| |
| linkDest.delete(IResource.NONE, getMonitor()); |
| assertTrue("1.4", !linkDest.exists()); |
| assertTrue("1.5", !overlapDest.exists()); |
| assertOverlap("1.6", linkDest, overlapDest); |
| } catch (CoreException e) { |
| fail("1.99", e); |
| } |
| //duplicate file |
| try { |
| IFile linkDest = lLinked; |
| IFile overlapDest = lOverlap; |
| //first delete the file, then copy it back |
| overlapDest.delete(IResource.NONE, getMonitor()); |
| //the link will still exist, but the location won't |
| assertTrue("2.1", linkDest.exists()); |
| assertTrue("2.2", !overlapDest.exists()); |
| assertTrue("2.3", !linkDest.getLocation().toFile().exists()); |
| assertEquals("2.4", linkDest.getLocation(), overlapDest.getLocation()); |
| |
| sourceFile.copy(overlapDest.getFullPath(), IResource.NONE, getMonitor()); |
| assertTrue("2.4", linkDest.exists()); |
| assertTrue("2.5", overlapDest.exists()); |
| assertOverlap("2.6", linkDest, overlapDest); |
| } catch (CoreException e) { |
| fail("2.99", e); |
| } |
| //file in duplicate folder |
| try { |
| IFile linkDest = fLinked.getFile("CopyDestination"); |
| IFile overlapDest = fOverlap.getFile(linkDest.getName()); |
| |
| sourceFile.copy(overlapDest.getFullPath(), IResource.NONE, getMonitor()); |
| assertTrue("3.1", linkDest.exists()); |
| assertTrue("3.2", overlapDest.exists()); |
| assertOverlap("3.3", linkDest, overlapDest); |
| |
| overlapDest.delete(IResource.NONE, getMonitor()); |
| assertTrue("3.4", !linkDest.exists()); |
| assertTrue("3.5", !overlapDest.exists()); |
| assertOverlap("3.6", linkDest, overlapDest); |
| } catch (CoreException e) { |
| fail("3.99", e); |
| } |
| } |
| |
| public void testCopyFolder() { |
| IFolder source = pNoOverlap.getFolder("CopyFolder"); |
| ensureExistsInWorkspace(source, true); |
| |
| IFolder destFolder1 = fLinkOverlap1.getFolder(source.getName()); |
| IFolder destFolder2 = fLinkOverlap2.getFolder(source.getName()); |
| IResource[] allDest = new IResource[] {destFolder1, destFolder2}; |
| assertDoesNotExistInWorkspace("1.0", allDest); |
| |
| //copy to dest 1 |
| try { |
| source.copy(destFolder1.getFullPath(), IResource.NONE, getMonitor()); |
| } catch (CoreException e) { |
| fail("1.1"); |
| } |
| assertExistsInWorkspace("1.2", allDest); |
| |
| try { |
| destFolder2.delete(IResource.NONE, getMonitor()); |
| } catch (CoreException e) { |
| fail("1.3", e); |
| } |
| |
| //copy to dest 2 |
| try { |
| source.copy(destFolder2.getFullPath(), IResource.NONE, getMonitor()); |
| } catch (CoreException e) { |
| fail("1.4"); |
| } |
| assertExistsInWorkspace("1.5", allDest); |
| |
| try { |
| destFolder1.delete(IResource.NONE, getMonitor()); |
| } catch (CoreException e) { |
| fail("1.6", e); |
| } |
| } |
| |
| /** |
| * Test copying a linked folder into a child of its alias. |
| */ |
| public void testCopyToChild() { |
| //copying link to child should fail |
| IFolder copyDest = fLinkOverlap1.getFolder("CopyDest"); |
| try { |
| fLinkOverlap2.copy(copyDest.getFullPath(), IResource.NONE, getMonitor()); |
| fail("1.0"); |
| } catch (CoreException e) { |
| //should fail |
| } |
| //moving link to child should fail |
| try { |
| fLinkOverlap2.move(copyDest.getFullPath(), IResource.NONE, getMonitor()); |
| fail("1.0"); |
| } catch (CoreException e) { |
| //should fail |
| } |
| |
| //copy to self should fail |
| IFolder copyDest2 = fLinkOverlap2.getFolder(copyDest.getName()); |
| try { |
| copyDest.create(IResource.NONE, true, getMonitor()); |
| } catch (CoreException e) { |
| fail("1.3"); |
| } |
| try { |
| copyDest.copy(copyDest2.getFullPath(), IResource.NONE, getMonitor()); |
| fail("1.0"); |
| } catch (CoreException e) { |
| //should fail |
| } |
| //moving link to self should fail |
| try { |
| copyDest.move(copyDest2.getFullPath(), IResource.NONE, getMonitor()); |
| fail("1.0"); |
| } catch (CoreException e) { |
| //should fail |
| } |
| } |
| |
| public void testCreateDeleteFile() { |
| //file in linked folder |
| try { |
| lChildLinked.delete(IResource.NONE, getMonitor()); |
| assertOverlap("1.1", lChildLinked, lChildOverlap); |
| lChildLinked.create(getRandomContents(), IResource.NONE, getMonitor()); |
| assertOverlap("1.2", lChildLinked, lChildOverlap); |
| } catch (CoreException e) { |
| fail("1.99", e); |
| } |
| //duplicate file |
| try { |
| lOverlap.delete(IResource.NONE, getMonitor()); |
| assertEquals("2.0", lLinked.getLocation(), lOverlap.getLocation()); |
| |
| assertTrue("2.1", !lOverlap.exists()); |
| assertTrue("2.2", !lOverlap.getLocation().toFile().exists()); |
| assertTrue("2.3", lOverlap.isSynchronized(IResource.DEPTH_INFINITE)); |
| |
| //now the linked resource will still exist but its local contents won't |
| assertTrue("2.4", lLinked.exists()); |
| assertTrue("2.5", !lLinked.getLocation().toFile().exists()); |
| assertTrue("2.6", lLinked.isSynchronized(IResource.DEPTH_INFINITE)); |
| try { |
| lLinked.setContents(getRandomContents(), IResource.NONE, getMonitor()); |
| //should fail |
| fail("2.7"); |
| } catch (CoreException e) { |
| //should fail |
| } |
| lOverlap.create(getRandomContents(), IResource.NONE, getMonitor()); |
| assertOverlap("2.8", lLinked, lOverlap); |
| } catch (CoreException e) { |
| fail("2.99", e); |
| } |
| //file in duplicate folder |
| try { |
| lChildOverlap.delete(IResource.NONE, getMonitor()); |
| assertOverlap("1.1", lChildLinked, lChildOverlap); |
| lChildOverlap.create(getRandomContents(), IResource.NONE, getMonitor()); |
| assertOverlap("1.2", lChildLinked, lChildOverlap); |
| } catch (CoreException e) { |
| fail("3.0", e); |
| } |
| } |
| |
| public void testCreateDeleteFolder() { |
| //folder in overlapping project |
| try { |
| fOverlap.delete(IResource.NONE, getMonitor()); |
| //linked resources don't disappear on deletion of underlying file |
| assertTrue("1.0", fLinked.exists()); |
| assertTrue("1.1", !fLinked.getLocation().toFile().exists()); |
| |
| fOverlap.create(IResource.NONE, true, getMonitor()); |
| assertOverlap("1.2", fOverlap, fLinked); |
| } catch (CoreException e) { |
| fail("1.99", e); |
| } |
| //linked folder |
| try { |
| fLinked.delete(IResource.NONE, getMonitor()); |
| //deleting a link should not delete file system contents |
| assertTrue("2.0", fOverlap.exists()); |
| assertTrue("2.1", fOverlap.getLocation().toFile().exists()); |
| |
| fLinked.createLink(fOverlap.getLocation(), IResource.NONE, getMonitor()); |
| assertOverlap("1.4", fOverlap, fLinked); |
| } catch (CoreException e) { |
| fail("2.99", e); |
| } |
| |
| //child of linked folders |
| IFolder child1 = fLinkOverlap1.getFolder("LinkChild"); |
| IFolder child2 = fLinkOverlap2.getFolder(child1.getName()); |
| |
| try { |
| child1.create(IResource.NONE, true, getMonitor()); |
| assertOverlap("3.0", child1, child2); |
| child1.delete(IResource.NONE, getMonitor()); |
| assertTrue("3.1", !child1.exists()); |
| assertTrue("3.2", !child2.exists()); |
| |
| child2.create(IResource.NONE, true, getMonitor()); |
| assertOverlap("3.3", child1, child2); |
| child2.delete(IResource.NONE, getMonitor()); |
| assertTrue("3.4", !child1.exists()); |
| assertTrue("3.5", !child2.exists()); |
| } catch (CoreException e) { |
| fail("3.99", e); |
| } |
| } |
| |
| public void testCreateDeleteLink() { |
| IFolder folder = pNoOverlap.getFolder("folder"); |
| IFile folderChild = folder.getFile("Child.txt"); |
| IFolder link = pLinked.getFolder("FolderLink"); |
| IFile linkChild = link.getFile(folderChild.getName()); |
| ensureExistsInWorkspace(folder, true); |
| ensureExistsInWorkspace(folderChild, true); |
| try { |
| link.createLink(folder.getLocationURI(), IResource.NONE, getMonitor()); |
| assertTrue("1.0", linkChild.exists()); |
| //manipulate file below overlapping folder and make sure alias under link is updated |
| folderChild.delete(IResource.NONE, getMonitor()); |
| assertTrue("1.1", !linkChild.exists()); |
| ensureExistsInWorkspace(folderChild, true); |
| assertTrue("1.2", linkChild.exists()); |
| |
| link.delete(IResource.NONE, getMonitor()); |
| assertTrue("1.3", !linkChild.exists()); |
| } catch (CoreException e) { |
| fail("1.99", e); |
| } |
| } |
| |
| public void testDeepLink() { |
| IFolder folder = pNoOverlap.getFolder("folder"); |
| IFile folderChild = folder.getFile("Child.txt"); |
| final IFolder linkParent = pLinked.getFolder("LinkParent"); |
| IFolder link = linkParent.getFolder("FolderLink"); |
| IFile linkChild = link.getFile(folderChild.getName()); |
| ensureExistsInWorkspace(new IResource[] {folder, folderChild, linkParent}, true); |
| try { |
| link.createLink(folder.getLocationURI(), IResource.NONE, getMonitor()); |
| assertTrue("1.0", linkChild.exists()); |
| |
| //manipulate file below overlapping folder and make sure alias under link is updated |
| folderChild.delete(IResource.NONE, getMonitor()); |
| assertTrue("1.1", !linkChild.exists()); |
| ensureExistsInWorkspace(folderChild, true); |
| assertTrue("1.2", linkChild.exists()); |
| |
| link.delete(IResource.NONE, getMonitor()); |
| assertTrue("1.3", !linkChild.exists()); |
| link.createLink(folder.getLocationURI(), IResource.NONE, getMonitor()); |
| |
| //close and reopen the project and ensure the alias is still updated |
| link.getProject().close(getMonitor()); |
| link.getProject().open(getMonitor()); |
| |
| folderChild.delete(IResource.NONE, getMonitor()); |
| assertTrue("2.1", !linkChild.exists()); |
| ensureExistsInWorkspace(folderChild, true); |
| assertTrue("2.2", linkChild.exists()); |
| |
| final AliasManager aliasManager = ((Workspace) getWorkspace()).getAliasManager(); |
| //force AliasManager to restart (simulates a shutdown/startup) |
| aliasManager.startup(null); |
| |
| folderChild.delete(IResource.NONE, getMonitor()); |
| assertTrue("3.1", !linkChild.exists()); |
| ensureExistsInWorkspace(folderChild, true); |
| assertTrue("3.2", linkChild.exists()); |
| |
| //delete the project that contains the links |
| IFile fileInLinkedProject = pLinked.getFile("fileInLinkedProject.txt"); |
| createFileInFileSystem(((Resource) fileInLinkedProject).getStore(), getRandomContents()); |
| try { |
| getWorkspace().getRoot().delete(IResource.NONE, getMonitor()); |
| } catch (CoreException e) { |
| //failure expected here because it is out of sync |
| } |
| |
| //ensure aliases are gone (bug 144458) |
| final IResource[] aliases = aliasManager.computeAliases(folder, ((Folder) folder).getStore()); |
| if (aliases != null) { |
| fail("Unexpected aliases: " + Arrays.toString(aliases)); |
| } |
| } catch (CoreException e) { |
| fail("1.99", e); |
| } |
| } |
| |
| public void testCreateOpenProject() { |
| //test creating a project whose location is within an existing link |
| IProject newProject = getWorkspace().getRoot().getProject("createOpenProject"); |
| IProjectDescription desc = getWorkspace().newProjectDescription(newProject.getName()); |
| desc.setLocationURI(fLinkOverlap1.getLocationURI()); |
| try { |
| newProject.create(desc, getMonitor()); |
| newProject.open(getMonitor()); |
| } catch (CoreException e) { |
| fail("1.99", e); |
| } |
| |
| //.project file should now exist in link |
| IFile linkChild = fLinkOverlap1.getFile(IProjectDescription.DESCRIPTION_FILE_NAME); |
| assertTrue("1.0", linkChild.exists()); |
| |
| // TODO more tests |
| } |
| |
| public void testDeepCopyLink() { |
| // TODO |
| } |
| |
| public void testDeepMoveLink() { |
| // TODO |
| } |
| |
| public void testDeleteLink() { |
| //test deletion of a link that overlaps a project location |
| IFolder linkOnProject = pLinked.getFolder("LinkOnProject"); |
| try { |
| linkOnProject.createLink(pOverlap.getLocation(), IResource.NONE, getMonitor()); |
| } catch (CoreException e) { |
| fail("1.0", e); |
| } |
| |
| try { |
| linkOnProject.delete(IResource.NONE, getMonitor()); |
| } catch (CoreException e) { |
| fail("2.0", e); |
| } |
| |
| //deletion of a link should not delete the project that it overlaps |
| assertTrue("2.1", !linkOnProject.exists()); |
| assertTrue("2.2", pOverlap.exists()); |
| assertTrue("2.3", fOverlap.exists()); |
| } |
| |
| public void testDeleteProject() { |
| // TODO |
| } |
| |
| /** |
| * Tests deletion of a project whose location on disk contains |
| * the location of another project. The nested project should |
| * be deleted automatically in this case. |
| */ |
| public void testDeleteProjectUnderProject() { |
| IProject parent = getWorkspace().getRoot().getProject("parent"); |
| IProject child = getWorkspace().getRoot().getProject("child"); |
| ensureExistsInWorkspace(parent, true); |
| |
| IProjectDescription childDesc = getWorkspace().newProjectDescription(child.getName()); |
| childDesc.setLocation(parent.getLocation().append(child.getName())); |
| try { |
| child.create(childDesc, getMonitor()); |
| child.open(getMonitor()); |
| } catch (CoreException e) { |
| fail("1.99", e); |
| } |
| |
| IFolder childDirInParent = parent.getFolder(child.getName()); |
| IFile childProjectFileInParent = childDirInParent.getFile(IProjectDescription.DESCRIPTION_FILE_NAME); |
| assertTrue("1.0", childDirInParent.exists()); |
| assertTrue("1.1", childProjectFileInParent.exists()); |
| |
| //now delete the child and ensure the resources in the parent are gone |
| try { |
| child.delete(IResource.NONE, getMonitor()); |
| } catch (CoreException e) { |
| fail("2.99", e); |
| } |
| assertTrue("2.0", !childDirInParent.exists()); |
| assertTrue("2.1", !childProjectFileInParent.exists()); |
| |
| //recreate the child and ensure resources in parent are there |
| try { |
| child.create(childDesc, getMonitor()); |
| child.open(getMonitor()); |
| } catch (CoreException e) { |
| fail("3.99", e); |
| } |
| assertTrue("3.0", childDirInParent.exists()); |
| assertTrue("3.1", childProjectFileInParent.exists()); |
| |
| //delete the parent and ensure child is also deleted |
| try { |
| parent.delete(IResource.NONE, getMonitor()); |
| } catch (CoreException e) { |
| fail("4.99", e); |
| } |
| |
| assertTrue("4.0", !parent.exists()); |
| assertTrue("4.1", !child.exists()); |
| assertTrue("4.2", !childDirInParent.exists()); |
| assertTrue("4.3", !childProjectFileInParent.exists()); |
| } |
| |
| public void testDeleteProjectContents() { |
| //delete the overlapping project - it should delete the children of the linked folder |
| //but leave the actual links intact in the resource tree |
| try { |
| pOverlap.delete(IResource.ALWAYS_DELETE_PROJECT_CONTENT, getMonitor()); |
| } catch (CoreException e) { |
| fail("1.0", e); |
| } |
| assertDoesNotExistInWorkspace("1.1", new IResource[] {pOverlap, fOverlap, lOverlap, lChildOverlap, lChildLinked}); |
| assertDoesNotExistInFileSystem("1.2", new IResource[] {pOverlap, fOverlap, lOverlap, lChildOverlap, lChildLinked, lLinked, fLinked}); |
| assertExistsInWorkspace("1.3", new IResource[] {pLinked, fLinked, lLinked}); |
| } |
| |
| public void testFileAppendContents() { |
| //linked file |
| try { |
| lLinked.appendContents(getRandomContents(), IResource.NONE, getMonitor()); |
| } catch (CoreException e) { |
| fail("1.0", e); |
| } |
| assertOverlap("1.1", lLinked, lOverlap); |
| |
| //file in linked folder |
| try { |
| lChildLinked.appendContents(getRandomContents(), IResource.NONE, getMonitor()); |
| } catch (CoreException e) { |
| fail("2.0", e); |
| } |
| assertOverlap("2.1", lChildLinked, lChildOverlap); |
| //duplicate file |
| try { |
| lOverlap.appendContents(getRandomContents(), IResource.NONE, getMonitor()); |
| } catch (CoreException e) { |
| fail("3.0", e); |
| } |
| assertOverlap("3.1", lLinked, lOverlap); |
| //file in duplicate folder |
| try { |
| lChildOverlap.appendContents(getRandomContents(), IResource.NONE, getMonitor()); |
| } catch (CoreException e) { |
| fail("3.0", e); |
| } |
| assertOverlap("3.1", lChildLinked, lChildOverlap); |
| } |
| |
| public void testFileSetContents() { |
| //linked file |
| try { |
| lLinked.setContents(getRandomContents(), IResource.NONE, getMonitor()); |
| } catch (CoreException e) { |
| fail("1.0", e); |
| } |
| assertOverlap("1.1", lLinked, lOverlap); |
| |
| //file in linked folder |
| try { |
| lChildLinked.setContents(getRandomContents(), IResource.NONE, getMonitor()); |
| } catch (CoreException e) { |
| fail("2.0", e); |
| } |
| assertOverlap("2.1", lChildLinked, lChildOverlap); |
| //duplicate file |
| try { |
| lOverlap.setContents(getRandomContents(), IResource.NONE, getMonitor()); |
| } catch (CoreException e) { |
| fail("3.0", e); |
| } |
| assertOverlap("3.1", lLinked, lOverlap); |
| //file in duplicate folder |
| try { |
| lChildOverlap.setContents(getRandomContents(), IResource.NONE, getMonitor()); |
| } catch (CoreException e) { |
| fail("3.0", e); |
| } |
| assertOverlap("3.1", lChildLinked, lChildOverlap); |
| } |
| |
| /** |
| * Tests moving a file into and out of an overlapping area (similar to |
| * creation/deletion). |
| */ |
| public void testMoveFile() { |
| IFile destination = pNoOverlap.getFile("MoveDestination"); |
| //file in linked folder |
| try { |
| lChildLinked.move(destination.getFullPath(), IResource.NONE, getMonitor()); |
| assertDoesNotExistInWorkspace("1.1", lChildLinked); |
| assertDoesNotExistInWorkspace("1.2", lChildOverlap); |
| assertExistsInWorkspace("1.3", destination); |
| assertOverlap("1.4", lChildLinked, lChildOverlap); |
| assertTrue("1.5", lChildLinked.isSynchronized(IResource.DEPTH_INFINITE)); |
| assertTrue("1.6", destination.isSynchronized(IResource.DEPTH_INFINITE)); |
| |
| destination.move(lChildLinked.getFullPath(), IResource.NONE, getMonitor()); |
| assertExistsInWorkspace("2.1", lChildLinked); |
| assertExistsInWorkspace("2.2", lChildOverlap); |
| assertDoesNotExistInWorkspace("2.3", destination); |
| assertOverlap("2.4", lChildLinked, lChildOverlap); |
| } catch (CoreException e) { |
| fail("1.99", e); |
| } |
| //duplicate file |
| try { |
| lOverlap.move(destination.getFullPath(), IResource.NONE, getMonitor()); |
| assertDoesNotExistInWorkspace("3.1", lOverlap); |
| assertExistsInWorkspace("3.2", lLinked); |
| assertDoesNotExistInFileSystem("3.25", lLinked); |
| assertExistsInWorkspace("3.3", destination); |
| assertEquals("3.4", lLinked.getLocation(), lOverlap.getLocation()); |
| assertTrue("3.4.1", lLinked.isSynchronized(IResource.DEPTH_INFINITE)); |
| |
| destination.move(lOverlap.getFullPath(), IResource.NONE, getMonitor()); |
| assertExistsInWorkspace("3.5", lLinked); |
| assertExistsInWorkspace("3.6", lOverlap); |
| assertDoesNotExistInWorkspace("3.7", destination); |
| assertOverlap("3.8", lLinked, lOverlap); |
| } catch (CoreException e) { |
| fail("2.99", e); |
| } |
| //file in duplicate folder |
| try { |
| lChildOverlap.move(destination.getFullPath(), IResource.NONE, getMonitor()); |
| assertDoesNotExistInWorkspace("3.1", lChildLinked); |
| assertDoesNotExistInWorkspace("3.2", lChildOverlap); |
| assertExistsInWorkspace("3.3", destination); |
| assertOverlap("3.4", lChildLinked, lChildOverlap); |
| |
| destination.move(lChildOverlap.getFullPath(), IResource.NONE, getMonitor()); |
| assertExistsInWorkspace("3.5", lChildLinked); |
| assertExistsInWorkspace("3.6", lChildOverlap); |
| assertDoesNotExistInWorkspace("3.7", destination); |
| assertOverlap("3.8", lChildLinked, lChildOverlap); |
| } catch (CoreException e) { |
| fail("3.0", e); |
| } |
| } |
| |
| public void testMoveFolder() { |
| // TODO |
| } |
| |
| public void testShallowCopyLink() { |
| // TODO |
| } |
| |
| public void testShallowMoveLink() { |
| // TODO |
| } |
| |
| public void testShallowDeleteProject() { |
| // TODO |
| } |
| } |