/*******************************************************************************
* Copyright (c) 2000, 2015 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
* Martin Oberhuber (Wind River) - testImportWrongLineEndings() for bug [210664]
* Serge Beauchamp (Freescale Semiconductor) - [229633] Add Project Path Variables
*******************************************************************************/
package org.eclipse.core.tests.resources;
import java.io.*;
import java.net.URI;
import java.util.ArrayList;
import junit.framework.Test;
import junit.framework.TestSuite;
import org.eclipse.core.filesystem.*;
import org.eclipse.core.filesystem.URIUtil;
import org.eclipse.core.internal.resources.Workspace;
import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.*;
import org.eclipse.core.tests.harness.FileSystemHelper;
/**
* This class extends <code>LinkedResourceTest</code> in order to use
* randomly generated locations that are always variable-based.
* TODO: add tests specific to linking resources using path variables (then
* removing the variable, change the variable value, etc)
*/
public class LinkedResourceWithPathVariableTest extends LinkedResourceTest {
private final static String VARIABLE_NAME = "ROOT";
private final static String PROJECT_VARIABLE_NAME = "PROOT";
private final static String PROJECT_RELATIVE_VARIABLE_NAME = "RELATIVE_PROOT";
private final static String PROJECT_RELATIVE_VARIABLE_VALUE = "${PROOT}";
private final ArrayList<IPath> toDelete = new ArrayList<>();
private IFileStore toSetWritable = null;
public LinkedResourceWithPathVariableTest() {
super();
}
public LinkedResourceWithPathVariableTest(String name) {
super(name);
}
public static Test suite() {
return new TestSuite(LinkedResourceWithPathVariableTest.class);
// TestSuite suite = new TestSuite();
// suite.addTest(new LinkedResourceWithPathVariableTest("testMoveFile"));
// return suite;
}
@Override
protected void setUp() throws Exception {
IPath base = super.getRandomLocation();
toDelete.add(base);
getWorkspace().getPathVariableManager().setValue(VARIABLE_NAME, base);
base = super.getRandomLocation();
toDelete.add(base);
super.setUp();
existingProject.getPathVariableManager().setValue(PROJECT_VARIABLE_NAME, base);
existingProject.getPathVariableManager().setValue(PROJECT_RELATIVE_VARIABLE_NAME, Path.fromPortableString(PROJECT_RELATIVE_VARIABLE_VALUE));
}
@Override
protected void tearDown() throws Exception {
if (toSetWritable != null) {
IFileInfo info = toSetWritable.fetchInfo();
info.setAttribute(EFS.ATTRIBUTE_READ_ONLY, false);
toSetWritable.putInfo(info, EFS.SET_ATTRIBUTES, getMonitor());
toSetWritable = null;
}
getWorkspace().getPathVariableManager().setValue(VARIABLE_NAME, null);
IPath[] paths = toDelete.toArray(new IPath[toDelete.size()]);
toDelete.clear();
for (IPath path : paths) {
Workspace.clear(path.toFile());
}
super.tearDown();
}
/**
* Copy file "inStore" into file "outStore", converting line endings as follows:
* <ul>
* <li>DOS, or MAC (CR or CRLF) into UNIX (LF)</li>
* <li>UNIX (LF) into DOS (CRLF)</li>
* </ul>
* @param inStore handle to an existing text file to convert
* @param outStore handle to non-existing file which will be written
*/
protected void convertLineEndings(IFileStore inStore, IFileStore outStore, IProgressMonitor mon) throws CoreException, IOException {
InputStream is = null;
OutputStream os = null;
try {
is = inStore.openInputStream(EFS.NONE, mon);
os = outStore.openOutputStream(EFS.NONE, new NullProgressMonitor());
int prevb = 0;
int ib = is.read();
while (ib >= 0) {
switch (ib) {
case '\r' :
os.write('\n');
break;
case '\n' :
if (prevb != '\r') { /* not converted already */
os.write('\r');
os.write('\n');
}
break;
default :
os.write(ib);
break;
}
prevb = ib;
ib = is.read();
}
} finally {
if (is != null) {
is.close();
}
if (os != null) {
os.close();
}
}
}
/**
* @see org.eclipse.core.tests.harness.ResourceTest#getRandomLocation()
*/
@Override
public IPath getRandomLocation() {
IPathVariableManager pathVars = getWorkspace().getPathVariableManager();
//low order bits are current time, high order bits are static counter
IPath parent = new Path(VARIABLE_NAME);
IPath path = FileSystemHelper.computeRandomLocation(parent);
while (pathVars.resolvePath(path).toFile().exists()) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// ignore
}
path = FileSystemHelper.computeRandomLocation(parent);
}
toDelete.add(pathVars.resolvePath(path));
return path;
}
/**
* @see org.eclipse.core.tests.harness.ResourceTest#getRandomLocation()
*/
public IPath getRandomProjectLocation() {
IPathVariableManager pathVars = getWorkspace().getPathVariableManager();
// low order bits are current time, high order bits are static counter
IPath parent = new Path(PROJECT_VARIABLE_NAME);
IPath path = FileSystemHelper.computeRandomLocation(parent);
while (pathVars.resolvePath(path).toFile().exists()) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// ignore
}
path = FileSystemHelper.computeRandomLocation(parent);
}
toDelete.add(pathVars.resolvePath(path));
return path;
}
/**
* @see org.eclipse.core.tests.harness.ResourceTest#getRandomLocation()
*/
public IPath getRandomRelativeProjectLocation() {
IPathVariableManager pathVars = getWorkspace().getPathVariableManager();
// low order bits are current time, high order bits are static counter
IPath parent = new Path(PROJECT_RELATIVE_VARIABLE_NAME);
IPath path = FileSystemHelper.computeRandomLocation(parent);
while (pathVars.resolvePath(path).toFile().exists()) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
// ignore
}
path = FileSystemHelper.computeRandomLocation(parent);
}
toDelete.add(pathVars.resolvePath(path));
return path;
}
/**
* @see LinkedResourceTest#resolve(org.eclipse.core.runtime.IPath)
*/
@Override
protected IPath resolve(IPath path) {
return getWorkspace().getPathVariableManager().resolvePath(path);
}
/**
* @see LinkedResourceTest#resolve(java.net.URI)
*/
@Override
protected URI resolve(URI uri) {
return getWorkspace().getPathVariableManager().resolveURI(uri);
}
public void testProjectResolution() {
final IPathVariableManager manager = existingProject.getPathVariableManager();
IPath value = manager.getValue(PROJECT_VARIABLE_NAME);
IPath relativeValue = manager.getValue(PROJECT_RELATIVE_VARIABLE_NAME);
assertTrue("1.0", !value.equals(relativeValue));
IPath resolvedValue = manager.resolvePath(value);
assertTrue("1.1", value.equals(resolvedValue));
IPath resolvedRelativeValue = manager.resolvePath(relativeValue);
assertTrue("1.2", !relativeValue.equals(resolvedRelativeValue));
assertTrue("1.3", resolvedValue.equals(resolvedRelativeValue));
}
/**
* Tests a scenario where a variable used in a linked file location is
* removed.
*/
public void testFileVariableRemoved() {
final IPathVariableManager manager = getWorkspace().getPathVariableManager();
IFile file = nonExistingFileInExistingProject;
IPath existingValue = manager.getValue(VARIABLE_NAME);
// creates a variable-based location
IPath variableBasedLocation = getRandomLocation();
// the file should not exist yet
assertDoesNotExistInWorkspace("1.0", file);
try {
file.createLink(variableBasedLocation, IResource.ALLOW_MISSING_LOCAL, null);
} catch (CoreException e) {
fail("1.1", e);
}
try {
file.setContents(getContents("contents for a file"), IResource.FORCE, null);
} catch (CoreException e) {
fail("1.2", e);
}
// now the file exists in both workspace and file system
assertExistsInWorkspace("2.0", file);
assertExistsInFileSystem("2.1", file);
// removes the variable - the location will be undefined (null)
try {
manager.setValue(VARIABLE_NAME, null);
} catch (CoreException e) {
fail("3.0", e);
}
assertExistsInWorkspace("3,1", file);
//refresh local - should not fail or make the link disappear
try {
file.refreshLocal(IResource.DEPTH_ONE, getMonitor());
file.getProject().refreshLocal(IResource.DEPTH_INFINITE, getMonitor());
} catch (CoreException e) {
fail("3.2");
}
assertExistsInWorkspace("3.3", file);
// try to change resource's contents
try {
file.setContents(getContents("new contents"), IResource.NONE, null);
// Resource has no-defined location - should fail
fail("3.4");
} catch (CoreException re) {
// success: resource had no defined location
}
assertExistsInWorkspace("3.5", file);
// the location is null
assertNull("3.6", file.getLocation());
// try validating another link location while there is a link with null location
IFile other = existingProject.getFile("OtherVar");
getWorkspace().validateLinkLocation(other, getRandomLocation());
// re-creates the variable with its previous value
try {
manager.setValue(VARIABLE_NAME, existingValue);
} catch (CoreException e) {
fail("4.0", e);
}
assertExistsInWorkspace("5.0", file);
assertNotNull("5.1", file.getLocation());
assertExistsInFileSystem("5.2", file);
// the contents must be the original ones
try {
assertTrue("5.3", compareContent(file.getContents(true), getContents("contents for a file")));
} catch (CoreException e) {
fail("5.4", e);
}
}
/**
* Tests a scenario where a variable used in a linked file location is
* removed.
*/
public void testFileProjectVariableRemoved() {
final IPathVariableManager manager = existingProject.getPathVariableManager();
IFile file = nonExistingFileInExistingProject;
IPath existingValue = manager.getValue(PROJECT_VARIABLE_NAME);
// creates a variable-based location
IPath variableBasedLocation = getRandomProjectLocation();
// the file should not exist yet
assertDoesNotExistInWorkspace("1.0", file);
try {
file.createLink(variableBasedLocation, IResource.ALLOW_MISSING_LOCAL, null);
} catch (CoreException e) {
fail("1.1", e);
}
try {
file.setContents(getContents("contents for a file"), IResource.FORCE, null);
} catch (CoreException e) {
fail("1.2", e);
}
// now the file exists in both workspace and file system
assertExistsInWorkspace("2.0", file);
assertExistsInFileSystem("2.1", file);
// removes the variable - the location will be undefined (null)
try {
manager.setValue(PROJECT_VARIABLE_NAME, null);
} catch (CoreException e) {
fail("3.0", e);
}
assertExistsInWorkspace("3,1", file);
// refresh local - should not fail or make the link disappear
try {
file.refreshLocal(IResource.DEPTH_ONE, getMonitor());
file.getProject().refreshLocal(IResource.DEPTH_INFINITE, getMonitor());
} catch (CoreException e) {
fail("3.2");
}
assertExistsInWorkspace("3.3", file);
// try to change resource's contents
try {
file.setContents(getContents("new contents"), IResource.NONE, null);
// Resource has no-defined location - should fail
fail("3.4");
} catch (CoreException re) {
// success: resource had no defined location
}
assertExistsInWorkspace("3.5", file);
// the location is null
assertNull("3.6", file.getLocation());
// try validating another link location while there is a link with null
// location
IFile other = existingProject.getFile("OtherVar");
getWorkspace().validateLinkLocation(other, getRandomLocation());
// re-creates the variable with its previous value
try {
manager.setValue(PROJECT_VARIABLE_NAME, existingValue);
} catch (CoreException e) {
fail("4.0", e);
}
assertExistsInWorkspace("5.0", file);
assertNotNull("5.1", file.getLocation());
assertExistsInFileSystem("5.2", file);
// the contents must be the original ones
try {
assertTrue("5.3", compareContent(file.getContents(true), getContents("contents for a file")));
} catch (CoreException e) {
fail("5.4", e);
}
}
/**
* Tests a scenario where a variable used in a linked file location is
* moved to a new project.
* This is a regression test for bug 266679
*/
public void testMoveFileToDifferentProject() {
IFile file = existingProjectInSubDirectory.getFile("my_link");
// creates a variable-based location
IPath variableBasedLocation = null;
IPath targetPath = existingProjectInSubDirectory.getLocation().removeLastSegments(1).append("outside.txt");
if (!targetPath.toFile().exists()) {
try {
targetPath.toFile().createNewFile();
} catch (IOException e2) {
fail("0.4", e2);
}
}
toDelete.add(targetPath);
try {
variableBasedLocation = convertToRelative(targetPath, file, true, null);
} catch (CoreException e1) {
fail("0.99", e1);
}
IPath resolvedPath = URIUtil.toPath(file.getPathVariableManager().resolveURI(URIUtil.toURI(variableBasedLocation)));
// the file should not exist yet
assertDoesNotExistInWorkspace("1.0", file);
try {
file.createLink(variableBasedLocation, IResource.ALLOW_MISSING_LOCAL, null);
} catch (CoreException e) {
fail("1.1", e);
}
assertExistsInWorkspace("2.0", file);
assertExistsInFileSystem("2.1", file);
IFile newFile = nonExistingFileInExistingFolder;
try {
file.move(newFile.getFullPath(), IResource.SHALLOW, null);
} catch (CoreException e) {
fail("3.0", e);
}
assertExistsInWorkspace("3,1", newFile);
assertTrue("3,2", !newFile.getLocation().equals(newFile.getRawLocation()));
assertEquals("3,3", newFile.getLocation(), resolvedPath);
}
private IPath convertToRelative(IPath path, IResource res, boolean force, String variableHint) throws CoreException {
return URIUtil.toPath(res.getPathVariableManager().convertToRelative(URIUtil.toURI(path), force, variableHint));
}
/**
* Tests a scenario where a variable used in a linked file location that is
* relative to PROJECT_LOC is moved to a different project.
* This is a regression test for bug 266679
*/
public void testPROJECT_LOC_MoveFileToDifferentProject() {
String[] existingVariables = nonExistingFileInExistingFolder.getProject().getPathVariableManager().getPathVariableNames();
for (String existingVariable : existingVariables) {
try {
nonExistingFileInExistingFolder.getProject().getPathVariableManager().setValue(existingVariable, null);
} catch (CoreException e) {
}
}
IFile file = existingProjectInSubDirectory.getFile("my_link2");
// creates a variable-based location
IPath variableBasedLocation = null;
IPath targetPath = existingProjectInSubDirectory.getLocation().removeLastSegments(3).append("outside.txt");
if (!targetPath.toFile().exists()) {
try {
targetPath.toFile().createNewFile();
} catch (IOException e2) {
fail("0.4", e2);
}
}
toDelete.add(targetPath);
try {
existingProjectInSubDirectory.getPathVariableManager().setValue("P_RELATIVE", Path.fromPortableString("${PARENT-3-PROJECT_LOC}"));
variableBasedLocation = Path.fromPortableString("P_RELATIVE/outside.txt");
} catch (CoreException e1) {
fail("0.99", e1);
}
IPath resolvedPath = existingProjectInSubDirectory.getPathVariableManager().resolvePath(variableBasedLocation);
// the file should not exist yet
assertDoesNotExistInWorkspace("1.0", file);
try {
file.createLink(variableBasedLocation, IResource.ALLOW_MISSING_LOCAL, null);
} catch (CoreException e) {
fail("1.1", e);
}
assertExistsInWorkspace("2.0", file);
assertExistsInFileSystem("2.1", file);
IFile newFile = nonExistingFileInExistingFolder;
try {
file.move(newFile.getFullPath(), IResource.SHALLOW, null);
} catch (CoreException e) {
fail("3.0", e);
}
assertExistsInWorkspace("3,1", newFile);
IPath newLocation = newFile.getLocation();
assertTrue("3,2", !newLocation.equals(newFile.getRawLocation()));
IPath newRawLocation = newFile.getRawLocation();
/* we cannot test the value of the location since the test machines generate an incorrect value
IPath newValue = newFile.getProject().getPathVariableManager().getValue("P_RELATIVE");
assertEquals("3,3", Path.fromPortableString("${PARENT-1-PROJECT_LOC}/sub"), newValue);
*/
assertTrue("3,4", newRawLocation.equals(variableBasedLocation));
assertTrue("3,5", newLocation.equals(resolvedPath));
}
/**
* Tests a scenario where a linked file location is
* is moved to a new project.
*/
public void testMoveFileProjectVariable() {
final IPathVariableManager manager = existingProject.getPathVariableManager();
IFile file = nonExistingFileInExistingProject;
// creates a variable-based location
IPath variableBasedLocation = getRandomProjectLocation();
IPath resolvedPath = manager.resolvePath(variableBasedLocation);
// the file should not exist yet
assertDoesNotExistInWorkspace("1.0", file);
try {
file.createLink(variableBasedLocation, IResource.ALLOW_MISSING_LOCAL, null);
} catch (CoreException e) {
fail("1.1", e);
}
try {
file.setContents(getContents("contents for a file"), IResource.FORCE, null);
} catch (CoreException e) {
fail("1.2", e);
}
// now the file exists in both workspace and file system
assertExistsInWorkspace("2.0", file);
assertExistsInFileSystem("2.1", file);
IFile newFile = nonExistingFileInExistingFolder;
// removes the variable - the location will be undefined (null)
try {
file.move(newFile.getFullPath(), IResource.SHALLOW, null);
} catch (CoreException e) {
fail("3.0", e);
}
assertExistsInWorkspace("3,1", newFile);
assertTrue("3,2", !newFile.getLocation().equals(newFile.getRawLocation()));
assertTrue("3,3", newFile.getRawLocation().equals(variableBasedLocation));
assertTrue("3,4", newFile.getRawLocation().equals(variableBasedLocation));
assertTrue("3,5", newFile.getLocation().equals(resolvedPath));
}
/**
* Tests a scenario where a variable used in a linked file location is
* removed.
*/
public void testMoveFileToNewProjectProjectVariable() {
final IPathVariableManager manager = existingProject.getPathVariableManager();
IFile file = nonExistingFileInExistingProject;
// creates a variable-based location
IPath variableBasedLocation = getRandomRelativeProjectLocation();
IPath resolvedPath = manager.resolvePath(variableBasedLocation);
// the file should not exist yet
assertDoesNotExistInWorkspace("1.0", file);
try {
file.createLink(variableBasedLocation, IResource.ALLOW_MISSING_LOCAL, null);
} catch (CoreException e) {
fail("1.1", e);
}
try {
file.setContents(getContents("contents for a file"), IResource.FORCE, null);
} catch (CoreException e) {
fail("1.2", e);
}
// now the file exists in both workspace and file system
assertExistsInWorkspace("2.0", file);
assertExistsInFileSystem("2.1", file);
IFile newFile = nonExistingFileInOtherExistingProject;
// moves the variable - the location will be undefined (null)
try {
file.move(newFile.getFullPath(), IResource.SHALLOW, getMonitor());
} catch (CoreException e) {
fail("3.0", e);
}
assertExistsInWorkspace("3,1", newFile);
assertTrue("3,2", !newFile.getLocation().equals(newFile.getRawLocation()));
assertTrue("3,3", newFile.getRawLocation().equals(variableBasedLocation));
assertTrue("3,4", newFile.getLocation().equals(resolvedPath));
}
/**
* Tests a scenario where a variable used in a linked file location is
* removed.
*/
public void testFileProjectRelativeVariableRemoved() {
final IPathVariableManager manager = existingProject.getPathVariableManager();
IFile file = nonExistingFileInExistingProject;
IPath existingValue = manager.getValue(PROJECT_RELATIVE_VARIABLE_NAME);
// creates a variable-based location
IPath variableBasedLocation = getRandomRelativeProjectLocation();
// the file should not exist yet
assertDoesNotExistInWorkspace("1.0", file);
try {
file.createLink(variableBasedLocation, IResource.ALLOW_MISSING_LOCAL, null);
} catch (CoreException e) {
fail("1.1", e);
}
try {
file.setContents(getContents("contents for a file"), IResource.FORCE, null);
} catch (CoreException e) {
fail("1.2", e);
}
// now the file exists in both workspace and file system
assertExistsInWorkspace("2.0", file);
assertExistsInFileSystem("2.1", file);
// removes the variable - the location will be undefined (null)
try {
manager.setValue(PROJECT_RELATIVE_VARIABLE_NAME, null);
} catch (CoreException e) {
fail("3.0", e);
}
assertExistsInWorkspace("3,1", file);
// refresh local - should not fail or make the link disappear
try {
file.refreshLocal(IResource.DEPTH_ONE, getMonitor());
file.getProject().refreshLocal(IResource.DEPTH_INFINITE, getMonitor());
} catch (CoreException e) {
fail("3.2");
}
assertExistsInWorkspace("3.3", file);
// try to change resource's contents
try {
file.setContents(getContents("new contents"), IResource.NONE, null);
// Resource has no-defined location - should fail
fail("3.4");
} catch (CoreException re) {
// success: resource had no defined location
}
assertExistsInWorkspace("3.5", file);
// the location is null
assertNull("3.6", file.getLocation());
// try validating another link location while there is a link with null
// location
IFile other = existingProject.getFile("OtherVar");
getWorkspace().validateLinkLocation(other, getRandomLocation());
// re-creates the variable with its previous value
try {
manager.setValue(PROJECT_RELATIVE_VARIABLE_NAME, existingValue);
} catch (CoreException e) {
fail("4.0", e);
}
assertExistsInWorkspace("5.0", file);
assertNotNull("5.1", file.getLocation());
assertExistsInFileSystem("5.2", file);
// the contents must be the original ones
try {
assertTrue("5.3", compareContent(file.getContents(true), getContents("contents for a file")));
} catch (CoreException e) {
fail("5.4", e);
}
}
/**
* Tests a scenario where a variable used in a linked folder location is
* removed.
*/
public void testFolderVariableRemoved() {
final IPathVariableManager manager = getWorkspace().getPathVariableManager();
IFolder folder = nonExistingFolderInExistingProject;
IFile childFile = folder.getFile(childName);
IPath existingValue = manager.getValue(VARIABLE_NAME);
// creates a variable-based location
IPath variableBasedLocation = getRandomLocation();
// the file should not exist yet
assertDoesNotExistInWorkspace("1.0", folder);
try {
folder.createLink(variableBasedLocation, IResource.ALLOW_MISSING_LOCAL, null);
childFile.create(getRandomContents(), IResource.NONE, getMonitor());
} catch (CoreException e) {
fail("1.1", e);
}
try {
childFile.setContents(getContents("contents for a file"), IResource.FORCE, null);
} catch (CoreException e) {
fail("1.2", e);
}
// now the file exists in both workspace and file system
assertExistsInWorkspace("2.0", folder);
assertExistsInWorkspace("2.1", childFile);
assertExistsInFileSystem("2.2", folder);
assertExistsInFileSystem("2.3", childFile);
// removes the variable - the location will be undefined (null)
try {
manager.setValue(VARIABLE_NAME, null);
} catch (CoreException e) {
fail("3.0", e);
}
assertExistsInWorkspace("3.1", folder);
//refresh local - should not fail but should cause link's children to disappear
try {
folder.refreshLocal(IResource.DEPTH_INFINITE, getMonitor());
folder.getProject().refreshLocal(IResource.DEPTH_INFINITE, getMonitor());
} catch (CoreException e) {
fail("3.2", e);
}
assertExistsInWorkspace("3.3", folder);
assertDoesNotExistInWorkspace("3.4", childFile);
//try to copy a file to the folder
IFile destination = folder.getFile(existingFileInExistingProject.getName());
try {
existingFileInExistingProject.copy(destination.getFullPath(), IResource.NONE, getMonitor());
//should fail
fail("3.5");
} catch (CoreException e) {
//expected
}
assertTrue("3.6", !destination.exists());
//try to create a sub-file
try {
destination.create(getRandomContents(), IResource.NONE, getMonitor());
//should fail
fail("3.7");
} catch (CoreException e) {
//expected
}
//try to create a sub-folder
IFolder subFolder = folder.getFolder("SubFolder");
try {
subFolder.create(IResource.NONE, true, getMonitor());
//should fail
fail("3.8");
} catch (CoreException e) {
//expected
}
// try to change resource's contents
try {
childFile.setContents(getContents("new contents"), IResource.NONE, null);
// Resource has no-defined location - should fail
fail("4.0");
} catch (CoreException re) {
// success: resource had no defined location
}
assertExistsInWorkspace("4.1", folder);
// the location is null
assertNull("4.2", folder.getLocation());
// re-creates the variable with its previous value
try {
manager.setValue(VARIABLE_NAME, existingValue);
} catch (CoreException e) {
fail("5.0", e);
}
assertExistsInWorkspace("6.0", folder);
assertNotNull("6.1", folder.getLocation());
assertExistsInFileSystem("6.2", folder);
assertDoesNotExistInWorkspace("6.3", childFile);
assertExistsInFileSystem("6.4", childFile);
// refresh should recreate the child
try {
folder.refreshLocal(IResource.DEPTH_INFINITE, getMonitor());
} catch (CoreException e) {
fail("7.0", e);
}
assertExistsInWorkspace("7.1", folder);
assertExistsInWorkspace("7.2", childFile);
}
/**
* Tests importing a project with a Linked Resource and Path Variable,
* where the line endings in the .project file do not match the local
* Platform.
* The .project file must not be modified on import, especially if it
* is marked read-only.
* See <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=210664">Bug 210664</a>.
*/
public void testImportWrongLineEndings_Bug210664() throws IOException {
// Choose a project to work on
IProject proj = existingProject;
IFileStore projStore = null;
IPath randomLocationWithPathVariable = getRandomLocation();
try {
projStore = EFS.getStore(proj.getLocationURI());
} catch (CoreException e) {
fail("1.0", e);
}
// Don't run this test if we cannot set a file read-only
if ((projStore.getFileSystem().attributes() & EFS.ATTRIBUTE_READ_ONLY) == 0) {
return;
}
try {
// Create a linked resource with a non-existing path variable
IFolder folder = proj.getFolder("SOME_LINK");
folder.createLink(randomLocationWithPathVariable, IResource.ALLOW_MISSING_LOCAL, null);
// Close the project, and convert line endings
IFileStore projFile = projStore.getChild(".project");
proj.delete(IResource.NEVER_DELETE_PROJECT_CONTENT, getMonitor());
IFileStore projNew = projStore.getChild(".project.new");
convertLineEndings(projFile, projNew, getMonitor());
// Set the project read-only
projNew.move(projFile, EFS.OVERWRITE, getMonitor());
IFileInfo info = projFile.fetchInfo(EFS.NONE, getMonitor());
info.setAttribute(EFS.ATTRIBUTE_READ_ONLY, true);
projFile.putInfo(info, EFS.SET_ATTRIBUTES, getMonitor());
toSetWritable = projFile; /* for cleanup */
} catch (CoreException e) {
fail("2.0", e);
}
try {
//Bug 210664: Open project with wrong line endings and non-existing path variable
proj.create(null);
proj.open(IResource.NONE, getMonitor());
} catch (CoreException e) {
fail("3.0", e);
}
}
/**
* Tests a scenario where a variable used in a linked folder location is
* removed.
*/
public void testFolderProjectVariableRemoved() {
final IPathVariableManager manager = existingProject.getPathVariableManager();
IFolder folder = nonExistingFolderInExistingProject;
IFile childFile = folder.getFile(childName);
IPath existingValue = manager.getValue(PROJECT_VARIABLE_NAME);
// creates a variable-based location
IPath variableBasedLocation = getRandomProjectLocation();
// the file should not exist yet
assertDoesNotExistInWorkspace("1.0", folder);
try {
folder.createLink(variableBasedLocation, IResource.ALLOW_MISSING_LOCAL, null);
childFile.create(getRandomContents(), IResource.NONE, getMonitor());
} catch (CoreException e) {
fail("1.1", e);
}
try {
childFile.setContents(getContents("contents for a file"), IResource.FORCE, null);
} catch (CoreException e) {
fail("1.2", e);
}
// now the file exists in both workspace and file system
assertExistsInWorkspace("2.0", folder);
assertExistsInWorkspace("2.1", childFile);
assertExistsInFileSystem("2.2", folder);
assertExistsInFileSystem("2.3", childFile);
// removes the variable - the location will be undefined (null)
try {
manager.setValue(PROJECT_VARIABLE_NAME, null);
} catch (CoreException e) {
fail("3.0", e);
}
assertExistsInWorkspace("3.1", folder);
// refresh local - should not fail but should cause link's children to
// disappear
try {
folder.refreshLocal(IResource.DEPTH_INFINITE, getMonitor());
folder.getProject().refreshLocal(IResource.DEPTH_INFINITE, getMonitor());
} catch (CoreException e) {
fail("3.2", e);
}
assertExistsInWorkspace("3.3", folder);
assertDoesNotExistInWorkspace("3.4", childFile);
// try to copy a file to the folder
IFile destination = folder.getFile(existingFileInExistingProject.getName());
try {
existingFileInExistingProject.copy(destination.getFullPath(), IResource.NONE, getMonitor());
// should fail
fail("3.5");
} catch (CoreException e) {
// expected
}
assertTrue("3.6", !destination.exists());
// try to create a sub-file
try {
destination.create(getRandomContents(), IResource.NONE, getMonitor());
// should fail
fail("3.7");
} catch (CoreException e) {
// expected
}
// try to create a sub-folder
IFolder subFolder = folder.getFolder("SubFolder");
try {
subFolder.create(IResource.NONE, true, getMonitor());
// should fail
fail("3.8");
} catch (CoreException e) {
// expected
}
// try to change resource's contents
try {
childFile.setContents(getContents("new contents"), IResource.NONE, null);
// Resource has no-defined location - should fail
fail("4.0");
} catch (CoreException re) {
// success: resource had no defined location
}
assertExistsInWorkspace("4.1", folder);
// the location is null
assertNull("4.2", folder.getLocation());
// re-creates the variable with its previous value
try {
manager.setValue(PROJECT_VARIABLE_NAME, existingValue);
} catch (CoreException e) {
fail("5.0", e);
}
assertExistsInWorkspace("6.0", folder);
assertNotNull("6.1", folder.getLocation());
assertExistsInFileSystem("6.2", folder);
assertDoesNotExistInWorkspace("6.3", childFile);
assertExistsInFileSystem("6.4", childFile);
// refresh should recreate the child
try {
folder.refreshLocal(IResource.DEPTH_INFINITE, getMonitor());
} catch (CoreException e) {
fail("7.0", e);
}
assertExistsInWorkspace("7.1", folder);
assertExistsInWorkspace("7.2", childFile);
}
/**
* Tests scenario where links are relative to undefined variables
*/
public void testUndefinedVariable() {
IPath folderLocation = new Path("NOVAR/folder");
IPath fileLocation = new Path("NOVAR/abc.txt");
IFile testFile = existingProject.getFile("UndefinedVar.txt");
IFolder testFolder = existingProject.getFolder("UndefinedVarTest");
//should fail to create links
try {
testFile.createLink(fileLocation, IResource.NONE, getMonitor());
fail("1.0");
} catch (CoreException e) {
//should fail
}
try {
testFolder.createLink(folderLocation, IResource.NONE, getMonitor());
fail("1.1");
} catch (CoreException e) {
//should fail
}
//validate method should return warning
assertTrue("1.2", getWorkspace().validateLinkLocation(testFolder, folderLocation).getSeverity() == IStatus.WARNING);
assertTrue("1.3", getWorkspace().validateLinkLocation(testFile, fileLocation).getSeverity() == IStatus.WARNING);
//should succeed with ALLOW_MISSING_LOCAL
try {
testFile.createLink(fileLocation, IResource.ALLOW_MISSING_LOCAL, getMonitor());
} catch (CoreException e) {
fail("2.0", e);
}
try {
testFolder.createLink(folderLocation, IResource.ALLOW_MISSING_LOCAL, getMonitor());
} catch (CoreException e) {
fail("2.1", e);
}
//copy should fail
IPath copyFileDestination = existingProject.getFullPath().append("CopyFileDest");
IPath copyFolderDestination = existingProject.getFullPath().append("CopyFolderDest");
try {
testFile.copy(copyFileDestination, IResource.NONE, getMonitor());
fail("3.0");
} catch (CoreException e) {
//should fail
}
try {
testFolder.copy(copyFolderDestination, IResource.NONE, getMonitor());
fail("3.1");
} catch (CoreException e) {
//should fail
}
//move should fail
IPath moveFileDestination = existingProject.getFullPath().append("MoveFileDest");
IPath moveFolderDestination = existingProject.getFullPath().append("MoveFolderDest");
try {
testFile.move(moveFileDestination, IResource.NONE, getMonitor());
fail("4.0");
} catch (CoreException e) {
//should fail
}
try {
testFolder.move(moveFolderDestination, IResource.NONE, getMonitor());
fail("4.1");
} catch (CoreException e) {
//should fail
}
//refresh local should succeed
try {
testFile.refreshLocal(IResource.DEPTH_INFINITE, getMonitor());
testFolder.refreshLocal(IResource.DEPTH_INFINITE, getMonitor());
testFile.refreshLocal(IResource.DEPTH_ZERO, getMonitor());
testFolder.refreshLocal(IResource.DEPTH_ZERO, getMonitor());
existingProject.refreshLocal(IResource.NONE, getMonitor());
} catch (CoreException e) {
fail("5.0", e);
}
//renaming the project shallow is ok
try {
IProject project = testFolder.getProject();
IProjectDescription desc = project.getDescription();
desc.setName("moveDest");
project.move(desc, IResource.SHALLOW | IResource.FORCE, getMonitor());
} catch (CoreException e) {
fail("6.0");
}
//delete should succeed
try {
testFile.delete(IResource.NONE, getMonitor());
testFolder.delete(IResource.NONE, getMonitor());
} catch (CoreException e) {
fail("9.0", e);
}
}
/**
* Tests a scenario where a variable used in a linked file location is
* changed.
*/
public void testVariableChanged() {
final IPathVariableManager manager = getWorkspace().getPathVariableManager();
IPath existingValue = manager.getValue(VARIABLE_NAME);
IFile file = nonExistingFileInExistingProject;
// creates a variable-based location
IPath variableBasedLocation = getRandomLocation();
// the file should not exist yet
assertDoesNotExistInWorkspace("1.0", file);
try {
file.createLink(variableBasedLocation, IResource.ALLOW_MISSING_LOCAL, getMonitor());
} catch (CoreException e) {
fail("1.1", e);
}
try {
file.setContents(getContents("contents for a file"), IResource.FORCE, getMonitor());
} catch (CoreException e) {
fail("1.2", e);
}
// now the file exists in both workspace and file system
assertExistsInWorkspace("2.0", file);
assertExistsInFileSystem("2.1", file);
// changes the variable value - the file location will change
try {
IPath newLocation = super.getRandomLocation();
toDelete.add(newLocation);
manager.setValue(VARIABLE_NAME, newLocation);
} catch (CoreException e) {
fail("2.2", e);
}
// try to change resource's contents
try {
file.setContents(getContents("new contents"), IResource.NONE, getMonitor());
// Resource was out of sync - should not be able to change
fail("3.0");
} catch (CoreException e) {
assertEquals("3.1", IResourceStatus.OUT_OF_SYNC_LOCAL, e.getStatus().getCode());
}
assertExistsInWorkspace("3.2", file);
// the location is different - does not exist anymore
assertDoesNotExistInFileSystem("3.3", file);
// successfully changes resource's contents (using IResource.FORCE)
try {
file.setContents(getContents("contents in different location"), IResource.FORCE, getMonitor());
} catch (CoreException e) {
fail("4.0", e);
}
// now the file exists in a different location
assertExistsInFileSystem("4.1", file);
// its location must have changed reflecting the variable change
IPath expectedNewLocation = manager.resolvePath(variableBasedLocation);
IPath actualNewLocation = file.getLocation();
assertEquals("4.2", expectedNewLocation, actualNewLocation);
// its contents are as just set
try {
assertTrue("4.3", compareContent(file.getContents(), getContents("contents in different location")));
} catch (CoreException e) {
fail("4.4", e);
}
// clean-up
ensureDoesNotExistInFileSystem(file);
// restore the previous value
try {
manager.setValue(VARIABLE_NAME, existingValue);
} catch (CoreException e) {
fail("5.0", e);
}
assertExistsInWorkspace("5.1", file);
assertExistsInFileSystem("5.2", file);
// the contents must be the original ones
try {
assertTrue("5.3", compareContent(file.getContents(true), getContents("contents for a file")));
} catch (CoreException e) {
fail("5.4", e);
}
}
/**
* Tests a scenario where a variable used in a linked file location is
* changed.
*/
public void testProjectVariableChanged() {
final IPathVariableManager manager = existingProject.getPathVariableManager();
IPath existingValue = manager.getValue(PROJECT_VARIABLE_NAME);
IFile file = nonExistingFileInExistingProject;
// creates a variable-based location
IPath variableBasedLocation = getRandomProjectLocation();
// the file should not exist yet
assertDoesNotExistInWorkspace("1.0", file);
try {
file.createLink(variableBasedLocation, IResource.ALLOW_MISSING_LOCAL, getMonitor());
} catch (CoreException e) {
fail("1.1", e);
}
try {
file.setContents(getContents("contents for a file"), IResource.FORCE, getMonitor());
} catch (CoreException e) {
fail("1.2", e);
}
// now the file exists in both workspace and file system
assertExistsInWorkspace("2.0", file);
assertExistsInFileSystem("2.1", file);
// changes the variable value - the file location will change
try {
IPath newLocation = super.getRandomLocation();
toDelete.add(newLocation);
manager.setValue(PROJECT_VARIABLE_NAME, newLocation);
} catch (CoreException e) {
fail("2.2", e);
}
// try to change resource's contents
try {
file.setContents(getContents("new contents"), IResource.NONE, getMonitor());
// Resource was out of sync - should not be able to change
fail("3.0");
} catch (CoreException e) {
assertEquals("3.1", IResourceStatus.OUT_OF_SYNC_LOCAL, e.getStatus().getCode());
}
assertExistsInWorkspace("3.2", file);
// the location is different - does not exist anymore
assertDoesNotExistInFileSystem("3.3", file);
// successfully changes resource's contents (using IResource.FORCE)
try {
file.setContents(getContents("contents in different location"), IResource.FORCE, getMonitor());
} catch (CoreException e) {
fail("4.0", e);
}
// now the file exists in a different location
assertExistsInFileSystem("4.1", file);
// its location must have changed reflecting the variable change
IPath expectedNewLocation = manager.resolvePath(variableBasedLocation);
IPath actualNewLocation = file.getLocation();
assertEquals("4.2", expectedNewLocation, actualNewLocation);
// its contents are as just set
try {
assertTrue("4.3", compareContent(file.getContents(), getContents("contents in different location")));
} catch (CoreException e) {
fail("4.4", e);
}
// clean-up
ensureDoesNotExistInFileSystem(file);
// restore the previous value
try {
manager.setValue(PROJECT_VARIABLE_NAME, existingValue);
} catch (CoreException e) {
fail("5.0", e);
}
assertExistsInWorkspace("5.1", file);
assertExistsInFileSystem("5.2", file);
// the contents must be the original ones
try {
assertTrue("5.3", compareContent(file.getContents(true), getContents("contents for a file")));
} catch (CoreException e) {
fail("5.4", e);
}
}
/**
* Tests a scenario where a variable used in a linked file location is
* changed.
*/
// public void testGetPathVariable() {
// final IPathVariableManager manager = existingProject.getPathVariableManager();
// IPathVariable variable = manager.getPathVariable("PROJECT_LOC");
// assertTrue("1.0", variable != null);
// assertTrue("1.1", variable.isReadOnly());
// assertEquals("1.2", null, variable.getVariableHints());
//
// variable = manager.getPathVariable("PROJECT_LOC_does_not_exist");
// assertTrue("2.0", variable == null);
//
// variable = manager.getPathVariable("PARENT");
// assertTrue("3.0", variable != null);
// assertTrue("3.1", variable.isReadOnly());
// Object[] extensions = variable.getVariableHints();
// assertTrue("3.2", extensions == null);
//
// try {
// IPath newLocation = super.getRandomLocation();
// toDelete.add(newLocation);
// manager.setValue(PROJECT_VARIABLE_NAME, newLocation);
// } catch (CoreException e) {
// fail("4.1", e);
// }
// variable = manager.getPathVariable(PROJECT_VARIABLE_NAME);
// assertTrue("4.0", variable != null);
// assertTrue("4.1", !variable.isReadOnly());
// assertEquals("4.2", null, variable.getVariableHints());
// }
/**
* Test Bug 288880 - Redundant path variables generated when converting some linked resources to path variable-relative
*/
public void testNonRedundentPathVariablesGenerated() {
IFile file = existingProjectInSubDirectory.getFile("my_link");
IPathVariableManager pathVariableManager = existingProjectInSubDirectory.getPathVariableManager();
// creates a variable-based location
IPath variableBasedLocation = null;
IPath targetPath = existingProjectInSubDirectory.getLocation().removeLastSegments(1).append("outside.txt");
if (!targetPath.toFile().exists()) {
try {
targetPath.toFile().createNewFile();
} catch (IOException e2) {
fail("1.0", e2);
}
}
toDelete.add(targetPath);
try {
variableBasedLocation = convertToRelative(targetPath, file, true, null);
} catch (CoreException e1) {
fail("2.0", e1);
}
IPath resolvedPath = URIUtil.toPath(pathVariableManager.resolveURI(URIUtil.toURI(variableBasedLocation)));
// the file should not exist yet
assertDoesNotExistInWorkspace("3.0", file);
assertEquals("3.1", targetPath, resolvedPath);
try {
variableBasedLocation = convertToRelative(targetPath, file, true, null);
} catch (CoreException e1) {
fail("4.0", e1);
}
resolvedPath = URIUtil.toPath(pathVariableManager.resolveURI(URIUtil.toURI(variableBasedLocation)));
// the file should not exist yet
assertDoesNotExistInWorkspace("5.0", file);
assertEquals("5.1", targetPath, resolvedPath);
}
public void testConvertToUserEditableFormat() {
IPathVariableManager pathVariableManager = existingProject.getPathVariableManager();
String[][] table = { // format: {internal-format, user-editable-format [, internal-format-reconverted]
{"C:\\foo\\bar", "C:\\foo\\bar", "C:/foo/bar"}, //
{"C:/foo/bar", "C:/foo/bar"}, //
{"VAR/foo/bar", "VAR/foo/bar"}, //
{"${VAR}/foo/bar", "${VAR}/foo/bar"}, //
{"${VAR}/../foo/bar", "${VAR}/../foo/bar", "${PARENT-1-VAR}/foo/bar"}, //
{"${PARENT-1-VAR}/foo/bar", "${VAR}/../foo/bar"}, //
{"${PARENT-0-VAR}/foo/bar", "${VAR}/foo/bar", "${VAR}/foo/bar"}, //
{"${PARENT-VAR}/foo/bar", "${PARENT-VAR}/foo/bar"}, //
{"${PARENT-2}/foo/bar", "${PARENT-2}/foo/bar"}, //
{"${PARENT}/foo/bar", "${PARENT}/foo/bar"}, //
{"${PARENT-2-VAR}/foo/bar", "${VAR}/../../foo/bar"}, //
{"${PARENT-2-VAR}/foo/${PARENT-4-BAR}", "${VAR}/../../foo/${BAR}/../../../.."}, //
{"${PARENT-2-VAR}/foo${PARENT-4-BAR}", "${VAR}/../../foo${BAR}/../../../.."}, //
{"${PARENT-2-VAR}/${PARENT-4-BAR}/foo", "${VAR}/../../${BAR}/../../../../foo"}, //
{"${PARENT-2-VAR}/f${PARENT-4-BAR}/oo", "${VAR}/../../f${BAR}/../../../../oo"} //
};
for (int i = 0; i < table.length; i++) {
String result = pathVariableManager.convertToUserEditableFormat(toOS(table[i][0]), false);
assertEquals("1." + i, toOS(table[i][1]), result);
String original = pathVariableManager.convertFromUserEditableFormat(result, false);
assertEquals("2." + i, toOS(table[i].length == 2 ? table[i][0] : table[i][2]), original);
}
String[][] tableLocationFormat = { // format: {internal-format, user-editable-format [, internal-format-reconverted]
{"C:\\foo\\bar", "C:\\foo\\bar", "C:/foo/bar"}, //
{"C:/foo/bar", "C:/foo/bar"}, //
{"VAR/foo/bar", "VAR/foo/bar"}, //
{"${VAR}/../foo/bar", "${VAR}/../foo/bar", "PARENT-1-VAR/foo/bar"}, //
{"PARENT-1-VAR/foo/bar", "VAR/../foo/bar"}, //
{"PARENT-0-VAR/foo/bar", "VAR/foo/bar", "VAR/foo/bar"}, //
{"PARENT-VAR/foo/bar", "PARENT-VAR/foo/bar"}, //
{"PARENT-2/foo/bar", "PARENT-2/foo/bar"}, //
{"PARENT/foo/bar", "PARENT/foo/bar"}, //
{"PARENT-2-VAR/foo/bar", "VAR/../../foo/bar"}, //
{"PARENT-2-VAR/foo/PARENT-4-BAR", "VAR/../../foo/PARENT-4-BAR"}, //
{"PARENT-2-VAR/fooPARENT-4-BAR", "VAR/../../fooPARENT-4-BAR"}, //
{"PARENT-2-VAR/PARENT-4-BAR/foo", "VAR/../../PARENT-4-BAR/foo"}, //
{"PARENT-2-VAR/fPARENT-4-BAR/oo", "VAR/../../fPARENT-4-BAR/oo"}, //
{"/foo/bar", "/foo/bar"}, //
};
for (int i = 0; i < table.length; i++) {
String result = pathVariableManager.convertToUserEditableFormat(toOS(tableLocationFormat[i][0]), true);
assertEquals("3." + i, toOS(tableLocationFormat[i][1]), result);
String original = pathVariableManager.convertFromUserEditableFormat(result, true);
assertEquals("4." + i, toOS(tableLocationFormat[i].length == 2 ? tableLocationFormat[i][0] : tableLocationFormat[i][2]), original);
}
}
private String toOS(String path) {
return path.replace('/', File.separatorChar);
}
/**
* Regression for Bug 305676 - Selecting PARENT_LOC as the relative path variable in the ImportTypeDialog causes an error
*/
public void testPrefixVariablesAreNotConfused() {
URI uri = nonExistingFileInExistingFolder.getPathVariableManager().getURIValue("PARENT");
assertEquals("1.0", uri, null);
uri = nonExistingFileInExistingFolder.getPathVariableManager().getURIValue("PARENT_LOC");
assertNotNull("1.1", uri);
}
/**
* Regression test for Bug 338185 - Core Resource Variable Resolvers that do not specify the 'class' attribute are not displayed
*/
public void test338185() {
final IPathVariableManager manager = existingProject.getPathVariableManager();
String[] variables = manager.getPathVariableNames();
boolean found = false;
for (String variable : variables) {
if (variable.equals("Test338185")) {
found = true;
}
}
assertTrue(found);
}
}