/*******************************************************************************
* Copyright (c) 2007, 2015 Wind River Systems, Inc. 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:
* Martin Oberhuber (Wind River) - initial API and implementation
* John Arthorne (IBM) - [172346] disable tests with problematic Platform encoding
* Martin Oberhuber (Wind River) - [183137] liblocalfile for solaris-sparc
* Martin Oberhuber (Wind River) - [184433] liblocalfile for Linux x86_64
* Martin Oberhuber (Wind River) - [232426] push up createSymLink() to CoreTest
* Martin Oberhuber (Wind River) - [331716] Symlink test failures on Windows 7
* Sergey Prigogin (Google) - [440283] Modify symlink tests to run on Windows with or without administrator privileges
* [445805] Make sure symlink tests are green when run on Windows with administrator privileges
* [458989] Add a test case for setting ATTRIBUTE_HIDDEN on a symlink on Windows
*******************************************************************************/
package org.eclipse.core.tests.filesystem;
import java.io.OutputStream;
import org.eclipse.core.filesystem.*;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.Platform;
/**
*
*/
public class SymlinkTest extends FileSystemTest {
/**
* Symbolic links on Windows behave differently compared to Unix-based systems. Symbolic links
* on Windows have their own set of attributes independent from the attributes of the link's
* target. The {@link java.io.File#exists() File.exists()} method on Windows checks for
* existence of the symbolic link itself, not its target.
*/
private static final boolean SYMLINKS_ARE_FIRST_CLASS_FILES_OR_DIRECTORIES = isWindowsVistaOrHigher();
private static String specialCharName = "���� ��� ���� �����"; //$NON-NLS-1$
protected IFileStore aDir, aFile; //actual Dir, File
protected IFileInfo iDir, iFile, ilDir, ilFile, illDir, illFile;
protected IFileStore lDir, lFile; //symlink to Dir, File
protected IFileStore llDir, llFile; //link to link to Dir, File
public static IFileSystem getFileSystem() {
try {
return EFS.getFileSystem(EFS.SCHEME_FILE);
} catch (CoreException e) {
fail("getFileSystem", e);
}
return null;
}
public static IWorkspace getWorkspace() {
return ResourcesPlugin.getWorkspace();
}
protected void fetchFileInfos() {
iDir = aDir.fetchInfo();
iFile = aFile.fetchInfo();
ilDir = lDir.fetchInfo();
ilFile = lFile.fetchInfo();
illDir = llDir.fetchInfo();
illFile = llFile.fetchInfo();
}
public boolean haveSymlinks() {
return isAttributeSupported(EFS.ATTRIBUTE_SYMLINK);
}
protected void makeLinkStructure() {
aDir = baseStore.getChild("aDir");
aFile = baseStore.getChild("aFile");
lDir = baseStore.getChild("lDir");
lFile = baseStore.getChild("lFile");
llDir = baseStore.getChild("llDir");
llFile = baseStore.getChild("llFile");
ensureExists(aDir, true);
ensureExists(aFile, false);
mkLink(baseStore, "lDir", "aDir", true);
mkLink(baseStore, "llDir", "lDir", true);
mkLink(baseStore, "lFile", "aFile", false);
mkLink(baseStore, "llFile", "lFile", false);
fetchFileInfos();
}
protected void mkLink(IFileStore dir, String src, String tgt, boolean isDir) {
try {
createSymLink(dir.toLocalFile(EFS.NONE, getMonitor()), src, tgt, isDir);
} catch (CoreException e) {
fail("mkLink", e);
}
}
@Override
protected void setUp() throws Exception {
baseStore = getFileSystem().getStore(getWorkspace().getRoot().getLocation().append("temp"));
baseStore.mkdir(EFS.NONE, null);
}
@Override
protected void tearDown() throws Exception {
baseStore.delete(EFS.NONE, null);
}
public void testBrokenSymlinkAttributes() {
// Only activate this test if testing of symbolic links is possible.
if (!canCreateSymLinks()) {
return;
}
long testStartTime = System.currentTimeMillis();
makeLinkStructure();
//break links by removing actual dir and file
ensureDoesNotExist(aDir);
ensureDoesNotExist(aFile);
fetchFileInfos();
assertEquals(SYMLINKS_ARE_FIRST_CLASS_FILES_OR_DIRECTORIES, ilFile.exists());
assertFalse(ilFile.isDirectory());
assertEquals(SYMLINKS_ARE_FIRST_CLASS_FILES_OR_DIRECTORIES, illFile.exists());
assertFalse(illFile.isDirectory());
assertEquals(SYMLINKS_ARE_FIRST_CLASS_FILES_OR_DIRECTORIES, ilDir.exists());
assertEquals(SYMLINKS_ARE_FIRST_CLASS_FILES_OR_DIRECTORIES, ilDir.isDirectory());
assertEquals(SYMLINKS_ARE_FIRST_CLASS_FILES_OR_DIRECTORIES, illDir.exists());
assertEquals(SYMLINKS_ARE_FIRST_CLASS_FILES_OR_DIRECTORIES, illDir.isDirectory());
if (SYMLINKS_ARE_FIRST_CLASS_FILES_OR_DIRECTORIES) {
// Symlinks on Windows have their own modification time.
assertTrue(ilFile.getLastModified() >= testStartTime);
assertTrue(ilDir.getLastModified() >= testStartTime);
assertTrue(illFile.getLastModified() >= testStartTime);
assertTrue(illDir.getLastModified() >= testStartTime);
} else {
assertEquals(0, ilFile.getLastModified());
assertEquals(0, ilDir.getLastModified());
assertEquals(0, illFile.getLastModified());
assertEquals(0, illDir.getLastModified());
}
assertEquals(0, ilFile.getLength());
assertEquals(0, ilDir.getLength());
assertEquals(0, illFile.getLength());
assertEquals(0, illDir.getLength());
assertTrue(ilFile.getAttribute(EFS.ATTRIBUTE_SYMLINK));
assertEquals(ilFile.getStringAttribute(EFS.ATTRIBUTE_LINK_TARGET), "aFile");
assertTrue(ilDir.getAttribute(EFS.ATTRIBUTE_SYMLINK));
assertEquals(ilDir.getStringAttribute(EFS.ATTRIBUTE_LINK_TARGET), "aDir");
assertTrue(illFile.getAttribute(EFS.ATTRIBUTE_SYMLINK));
assertEquals(illFile.getStringAttribute(EFS.ATTRIBUTE_LINK_TARGET), "lFile");
assertTrue(illDir.getAttribute(EFS.ATTRIBUTE_SYMLINK));
assertEquals(illDir.getStringAttribute(EFS.ATTRIBUTE_LINK_TARGET), "lDir");
}
// Moving a broken symlink is possible.
public void testBrokenSymlinkMove() throws Exception {
// Only activate this test if testing of symbolic links is possible.
if (!canCreateSymLinks()) {
return;
}
makeLinkStructure();
ensureDoesNotExist(aFile);
ensureDoesNotExist(aDir);
IFileInfo[] infos = baseStore.childInfos(EFS.NONE, getMonitor());
assertEquals(infos.length, 4);
IFileStore _llFile = baseStore.getChild("_llFile");
IFileStore _llDir = baseStore.getChild("_llDir");
llFile.move(_llFile, EFS.NONE, getMonitor());
llDir.move(_llDir, EFS.NONE, getMonitor());
infos = baseStore.childInfos(EFS.NONE, getMonitor());
assertEquals(infos.length, 4);
assertFalse("1.0", containsSymlink(infos, llFile.getName()));
assertFalse("1.1", containsSymlink(infos, llDir.getName()));
assertTrue("1.2", containsSymlink(infos, _llFile.getName()));
assertTrue("1.3", containsSymlink(infos, _llFile.getName()));
IFileStore _lFile = baseStore.getChild("_lFile");
IFileStore _lDir = baseStore.getChild("_lDir");
lFile.move(_lFile, EFS.NONE, getMonitor());
lDir.move(_lDir, EFS.NONE, getMonitor());
infos = baseStore.childInfos(EFS.NONE, getMonitor());
assertEquals(infos.length, 4);
assertFalse("1.4", containsSymlink(infos, lFile.getName()));
assertFalse("1.5", containsSymlink(infos, lDir.getName()));
assertTrue("1.6", containsSymlink(infos, _lFile.getName()));
assertTrue("1.7", containsSymlink(infos, _lFile.getName()));
}
private boolean containsSymlink(IFileInfo[] infos, String link) {
for (IFileInfo info : infos) {
if (link.equals(info.getName())) {
if (info.getAttribute(EFS.ATTRIBUTE_SYMLINK)) {
return true;
}
}
}
return false;
}
// Removing a broken symlink is possible.
public void testBrokenSymlinkRemove() throws Exception {
// Only activate this test if testing of symbolic links is possible.
if (!canCreateSymLinks()) {
return;
}
makeLinkStructure();
ensureDoesNotExist(aFile);
ensureDoesNotExist(aDir);
IFileInfo[] infos = baseStore.childInfos(EFS.NONE, getMonitor());
assertEquals(infos.length, 4);
llFile.delete(EFS.NONE, getMonitor());
llDir.delete(EFS.NONE, getMonitor());
infos = baseStore.childInfos(EFS.NONE, getMonitor());
assertEquals(infos.length, 2);
lFile.delete(EFS.NONE, getMonitor());
lDir.delete(EFS.NONE, getMonitor());
infos = baseStore.childInfos(EFS.NONE, getMonitor());
assertEquals(infos.length, 0);
}
public void testRecursiveSymlink() throws Exception {
// Only activate this test if testing of symbolic links is possible.
if (!canCreateSymLinks()) {
return;
}
mkLink(baseStore, "l1", "l2", false);
mkLink(baseStore, "l2", "l1", false);
IFileStore l1 = baseStore.getChild("l1");
IFileInfo i1 = l1.fetchInfo();
assertEquals(SYMLINKS_ARE_FIRST_CLASS_FILES_OR_DIRECTORIES, i1.exists());
assertFalse(i1.isDirectory());
assertTrue(i1.getAttribute(EFS.ATTRIBUTE_SYMLINK));
assertEquals("l2", i1.getStringAttribute(EFS.ATTRIBUTE_LINK_TARGET));
IFileInfo[] infos = baseStore.childInfos(EFS.NONE, getMonitor());
assertEquals(infos.length, 2);
i1.setAttribute(EFS.ATTRIBUTE_READ_ONLY, true);
boolean exceptionThrown = false;
try {
l1.putInfo(i1, EFS.SET_ATTRIBUTES, getMonitor());
} catch (CoreException ce) {
exceptionThrown = true;
}
i1 = l1.fetchInfo();
boolean fixMeFixed = false;
if (fixMeFixed) {
//FIXME bug: putInfo neither sets attributes nor throws an exception for broken symbolic links
assertTrue(exceptionThrown);
assertTrue(i1.getAttribute(EFS.ATTRIBUTE_READ_ONLY));
}
assertEquals(SYMLINKS_ARE_FIRST_CLASS_FILES_OR_DIRECTORIES, i1.exists());
i1.setLastModified(12345);
exceptionThrown = false;
try {
l1.putInfo(i1, EFS.SET_LAST_MODIFIED, getMonitor());
} catch (CoreException ce) {
exceptionThrown = true;
}
i1 = l1.fetchInfo();
//FIXME bug: putInfo neither sets attributes nor throws an exception for broken symbolic links
//assertTrue(exceptionThrown);
//assertEquals(i1.getLastModified(), 12345);
assertEquals(SYMLINKS_ARE_FIRST_CLASS_FILES_OR_DIRECTORIES, i1.exists());
l1.delete(EFS.NONE, getMonitor());
infos = baseStore.childInfos(EFS.NONE, getMonitor());
assertEquals(infos.length, 1);
}
public void testSymlinkAttributes() {
// Only activate this test if testing of symbolic links is possible.
if (!canCreateSymLinks()) {
return;
}
makeLinkStructure();
assertFalse(iFile.getAttribute(EFS.ATTRIBUTE_SYMLINK));
assertFalse(iDir.getAttribute(EFS.ATTRIBUTE_SYMLINK));
//valid links
assertTrue(ilFile.exists());
assertFalse(ilFile.isDirectory());
assertTrue(illFile.exists());
assertFalse(illFile.isDirectory());
assertTrue(ilDir.exists());
assertTrue(ilDir.isDirectory());
assertTrue(illDir.exists());
assertTrue(illDir.isDirectory());
if (SYMLINKS_ARE_FIRST_CLASS_FILES_OR_DIRECTORIES) {
// Symlinks on Windows have their own modification time and zero size.
assertTrue(illFile.getLastModified() >= iFile.getLastModified());
assertEquals(0, illFile.getLength());
assertTrue(illDir.getLastModified() >= iDir.getLastModified());
assertEquals(0, illDir.getLength());
} else {
assertEquals(iFile.getLastModified(), illFile.getLastModified());
assertEquals(iFile.getLength(), illFile.getLength());
assertEquals(iDir.getLastModified(), illDir.getLastModified());
assertEquals(iDir.getLength(), illDir.getLength());
}
assertTrue(ilFile.getAttribute(EFS.ATTRIBUTE_SYMLINK));
assertEquals(ilFile.getStringAttribute(EFS.ATTRIBUTE_LINK_TARGET), "aFile");
assertTrue(ilDir.getAttribute(EFS.ATTRIBUTE_SYMLINK));
assertEquals(ilDir.getStringAttribute(EFS.ATTRIBUTE_LINK_TARGET), "aDir");
assertTrue(illFile.getAttribute(EFS.ATTRIBUTE_SYMLINK));
assertEquals(illFile.getStringAttribute(EFS.ATTRIBUTE_LINK_TARGET), "lFile");
assertTrue(illDir.getAttribute(EFS.ATTRIBUTE_SYMLINK));
assertEquals(illDir.getStringAttribute(EFS.ATTRIBUTE_LINK_TARGET), "lDir");
}
// Reading from a directory pointed to by a link is possible.
public void testSymlinkDirRead() throws Exception {
// Only activate this test if testing of symbolic links is possible.
if (!canCreateSymLinks()) {
return;
}
makeLinkStructure();
IFileStore childDir = aDir.getChild("subDir");
ensureExists(childDir, true);
IFileInfo[] infos = llDir.childInfos(EFS.NONE, getMonitor());
assertEquals(infos.length, 1);
assertTrue(infos[0].isDirectory());
assertFalse(infos[0].getAttribute(EFS.ATTRIBUTE_SYMLINK));
assertNull(infos[0].getStringAttribute(EFS.ATTRIBUTE_LINK_TARGET));
assertEquals(infos[0].getName(), "subDir");
ensureDoesNotExist(childDir);
}
// Writing to symlinked dir.
public void testSymlinkDirWrite() throws Exception {
// Only activate this test if testing of symbolic links is possible.
if (!canCreateSymLinks()) {
return;
}
makeLinkStructure();
IFileStore childFile = llDir.getChild("subFile");
ensureExists(childFile, false);
IFileInfo[] infos = aDir.childInfos(EFS.NONE, getMonitor());
assertEquals(infos.length, 1);
assertFalse(infos[0].isDirectory());
assertFalse(infos[0].getAttribute(EFS.ATTRIBUTE_SYMLINK));
assertNull(infos[0].getStringAttribute(EFS.ATTRIBUTE_LINK_TARGET));
assertEquals(infos[0].getName(), "subFile");
//writing to broken symlink
ensureDoesNotExist(aDir);
childFile = llDir.getChild("subFile");
OutputStream out = null;
boolean exceptionThrown = false;
try {
out = childFile.openOutputStream(EFS.NONE, getMonitor());
} catch (CoreException ce) {
exceptionThrown = true;
}
if (out != null) {
out.close();
}
assertNull(out);
assertTrue(exceptionThrown);
}
public void testSymlinkEnabled() {
String os = Platform.getOS();
String arch = Platform.getOSArch();
if (Platform.OS_LINUX.equals(os) || (Platform.OS_SOLARIS.equals(os) && Platform.ARCH_SPARC.equals(arch)) || Platform.OS_MACOSX.equals(os) || Platform.OS_AIX.equals(os) || isWindowsVistaOrHigher()) {
assertTrue(haveSymlinks());
} else {
assertFalse(haveSymlinks());
}
}
/**
* TODO Fix this test. See https://bugs.eclipse.org/bugs/show_bug.cgi?id=172346
*/
public void _testSymlinkExtendedChars() throws Exception {
// Only activate this test if testing of symbolic links is possible.
if (!canCreateSymLinks()) {
return;
}
IFileStore childDir = baseStore.getChild(specialCharName);
ensureExists(childDir, true);
IFileStore childFile = baseStore.getChild("ff" + specialCharName);
ensureExists(childFile, false);
mkLink(baseStore, "l" + specialCharName, specialCharName, true);
mkLink(baseStore, "lf" + specialCharName, "ff" + specialCharName, false);
IFileInfo[] infos = baseStore.childInfos(EFS.NONE, getMonitor());
assertEquals("0.1", infos.length, 4);
for (IFileInfo info : infos) {
String infoName = info.getName();
assertTrue("1." + infoName, infoName.endsWith(specialCharName));
assertTrue("2." + infoName, info.exists());
if (info.getName().charAt(1) == 'f') {
assertFalse("3." + infoName, info.isDirectory());
} else {
assertTrue("4." + infoName, info.isDirectory());
}
if (info.getName().charAt(0) == 'l') {
assertTrue("5." + infoName, info.getAttribute(EFS.ATTRIBUTE_SYMLINK));
assertTrue("6." + infoName, info.getStringAttribute(EFS.ATTRIBUTE_LINK_TARGET).endsWith(specialCharName));
}
}
}
public void testSymlinkPutLastModified() throws Exception {
// Only activate this test if testing of symbolic links is possible.
if (!canCreateSymLinks()) {
return;
}
if (Platform.OS_MACOSX.equals(Platform.getOS())) {
// flag EFS.SET_LAST_MODIFIED is set by java.io and it fails on Mac OS
return;
}
//check that putInfo() "writes through" the symlink
makeLinkStructure();
long oldTime = iFile.getLastModified();
long timeToSet = oldTime - 100000;
illFile.setLastModified(timeToSet);
llFile.putInfo(illFile, EFS.SET_ATTRIBUTES | EFS.SET_LAST_MODIFIED, getMonitor());
iFile = aFile.fetchInfo();
assertEquals(iFile.getLastModified(), timeToSet);
oldTime = iDir.getLastModified();
timeToSet = oldTime - 100000;
illDir.setLastModified(timeToSet);
llDir.putInfo(illDir, EFS.SET_ATTRIBUTES | EFS.SET_LAST_MODIFIED, getMonitor());
iDir = aDir.fetchInfo();
assertTrue(iDir.getLastModified() != oldTime);
assertEquals(iDir.getLastModified(), timeToSet);
// Check that link properties are maintained even through putInfo
illFile = llFile.fetchInfo();
illDir = llDir.fetchInfo();
assertTrue(illFile.getAttribute(EFS.ATTRIBUTE_SYMLINK));
assertTrue(illDir.getAttribute(EFS.ATTRIBUTE_SYMLINK));
assertEquals(illFile.getStringAttribute(EFS.ATTRIBUTE_LINK_TARGET), "lFile");
assertEquals(illDir.getStringAttribute(EFS.ATTRIBUTE_LINK_TARGET), "lDir");
}
public void testSymlinkPutReadOnly() throws Exception {
// Only activate this test if testing of symbolic links is possible.
if (!canCreateSymLinks()) {
return;
}
//check that putInfo() "writes through" the symlink
makeLinkStructure();
illFile.setAttribute(EFS.ATTRIBUTE_READ_ONLY, true);
llFile.putInfo(illFile, EFS.SET_ATTRIBUTES, getMonitor());
iFile = aFile.fetchInfo();
assertEquals(!SYMLINKS_ARE_FIRST_CLASS_FILES_OR_DIRECTORIES, iFile.getAttribute(EFS.ATTRIBUTE_READ_ONLY));
illFile.setAttribute(EFS.ATTRIBUTE_READ_ONLY, false);
llFile.putInfo(illFile, EFS.SET_ATTRIBUTES, getMonitor());
iFile = aFile.fetchInfo();
assertFalse(iFile.getAttribute(EFS.ATTRIBUTE_READ_ONLY));
illDir.setAttribute(EFS.ATTRIBUTE_READ_ONLY, true);
llDir.putInfo(illDir, EFS.SET_ATTRIBUTES, getMonitor());
iDir = aDir.fetchInfo();
assertEquals(!SYMLINKS_ARE_FIRST_CLASS_FILES_OR_DIRECTORIES, iDir.getAttribute(EFS.ATTRIBUTE_READ_ONLY));
illDir.setAttribute(EFS.ATTRIBUTE_READ_ONLY, false);
llDir.putInfo(illDir, EFS.SET_ATTRIBUTES, getMonitor());
iDir = aDir.fetchInfo();
assertFalse(iDir.getAttribute(EFS.ATTRIBUTE_READ_ONLY));
// Check that link properties are maintained even through putInfo
illFile = llFile.fetchInfo();
illDir = llDir.fetchInfo();
assertTrue(illFile.getAttribute(EFS.ATTRIBUTE_SYMLINK));
assertTrue(illDir.getAttribute(EFS.ATTRIBUTE_SYMLINK));
assertEquals(illFile.getStringAttribute(EFS.ATTRIBUTE_LINK_TARGET), "lFile");
assertEquals(illDir.getStringAttribute(EFS.ATTRIBUTE_LINK_TARGET), "lDir");
}
public void testSymlinkPutExecutable() throws Exception {
if (!isAttributeSupported(EFS.ATTRIBUTE_EXECUTABLE)) {
return;
}
// Only activate this test if testing of symbolic links is possible.
if (!canCreateSymLinks())
{
return;
// ATTRIBUTE_EXECUTABLE is not supported on Windows, so
// SYMLINKS_ARE_FIRST_CLASS_FILES_OR_DIRECTORIES is false in this context.
}
//check that putInfo() "writes through" the symlink
makeLinkStructure();
illFile.setAttribute(EFS.ATTRIBUTE_EXECUTABLE, true);
llFile.putInfo(illFile, EFS.SET_ATTRIBUTES, getMonitor());
iFile = aFile.fetchInfo();
assertTrue(iFile.getAttribute(EFS.ATTRIBUTE_EXECUTABLE));
illDir.setAttribute(EFS.ATTRIBUTE_EXECUTABLE, false);
llDir.putInfo(illDir, EFS.SET_ATTRIBUTES, getMonitor());
iDir = aDir.fetchInfo();
assertFalse(iDir.getAttribute(EFS.ATTRIBUTE_EXECUTABLE));
// Check that link properties are maintained even through putInfo
illFile = llFile.fetchInfo();
illDir = llDir.fetchInfo();
assertTrue(illFile.getAttribute(EFS.ATTRIBUTE_SYMLINK));
assertTrue(illDir.getAttribute(EFS.ATTRIBUTE_SYMLINK));
assertEquals(illFile.getStringAttribute(EFS.ATTRIBUTE_LINK_TARGET), "lFile");
assertEquals(illDir.getStringAttribute(EFS.ATTRIBUTE_LINK_TARGET), "lDir");
}
public void testSymlinkPutHidden() throws Exception {
if (!isAttributeSupported(EFS.ATTRIBUTE_HIDDEN)) {
return;
}
// Only activate this test if testing of symbolic links is possible.
if (!canCreateSymLinks())
{
return;
// ATTRIBUTE_HIDDEN is supported only on Windows, so
// SYMLINKS_ARE_FIRST_CLASS_FILES_OR_DIRECTORIES is true in this context.
}
// Check that putInfo() applies the attribute to the symlink itself.
makeLinkStructure();
illFile.setAttribute(EFS.ATTRIBUTE_HIDDEN, true);
llFile.putInfo(illFile, EFS.SET_ATTRIBUTES, getMonitor());
illFile = llFile.fetchInfo();
assertTrue(illFile.getAttribute(EFS.ATTRIBUTE_HIDDEN));
iFile = aFile.fetchInfo();
assertFalse(iFile.getAttribute(EFS.ATTRIBUTE_HIDDEN));
illDir.setAttribute(EFS.ATTRIBUTE_HIDDEN, true);
llDir.putInfo(illDir, EFS.SET_ATTRIBUTES, getMonitor());
illDir = llDir.fetchInfo();
assertTrue(illDir.getAttribute(EFS.ATTRIBUTE_HIDDEN));
iDir = aDir.fetchInfo();
assertFalse(iDir.getAttribute(EFS.ATTRIBUTE_HIDDEN));
// Check that link properties are maintained even through putInfo.
illFile = llFile.fetchInfo();
illDir = llDir.fetchInfo();
assertTrue(illFile.getAttribute(EFS.ATTRIBUTE_SYMLINK));
assertTrue(illDir.getAttribute(EFS.ATTRIBUTE_SYMLINK));
assertEquals(illFile.getStringAttribute(EFS.ATTRIBUTE_LINK_TARGET), "lFile");
assertEquals(illDir.getStringAttribute(EFS.ATTRIBUTE_LINK_TARGET), "lDir");
}
// Removing a symlink keeps the link target intact.
// Symlinks being broken due to remove are set to non-existent.
public void testSymlinkRemove() throws Exception {
// Only activate this test if testing of symbolic links is possible.
if (!canCreateSymLinks()) {
return;
}
makeLinkStructure();
lFile.delete(EFS.NONE, getMonitor());
illFile = lFile.fetchInfo();
assertFalse(illFile.exists());
iFile = aFile.fetchInfo();
assertTrue(iFile.exists());
IFileStore childFile = aDir.getChild("subFile");
ensureExists(childFile, false);
lDir.delete(EFS.NONE, getMonitor());
illDir = lDir.fetchInfo();
assertFalse(illFile.exists());
iDir = aDir.fetchInfo();
assertTrue(iDir.exists());
// Check that the contents of the directory are preserved.
IFileInfo iFileInsideDir = childFile.fetchInfo();
assertTrue(iFileInsideDir.exists());
}
}