blob: 04ac95eaed9fa7cf616c7e3a4379d3af038691f3 [file] [log] [blame]
/*
* Copyright (c) 2009, 2012, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/* @test
* @bug 6595866
* @summary Test java.io.File operations with sym links
* @build SymLinks Util
* @run main SymLinks
*/
import java.io.*;
import java.nio.file.*;
import java.nio.file.attribute.*;
import static java.nio.file.LinkOption.*;
public class SymLinks {
final static PrintStream out = System.out;
final static File top = new File(System.getProperty("test.dir", "."));
// files used by the test
final static File file = new File(top, "foofile");
final static File link2file = new File(top, "link2file");
final static File link2link2file = new File(top, "link2link2file");
final static File dir = new File(top, "foodir");
final static File link2dir = new File(top, "link2dir");
final static File link2link2dir = new File(top, "link2link2dir");
final static File link2nobody = new File(top, "link2nobody");
final static File link2link2nobody = new File(top, "link2link2nobody");
/**
* Setup files, directories, and sym links used by test.
*/
static void setup() throws IOException {
// link2link2file -> link2file -> foofile
FileOutputStream fos = new FileOutputStream(file);
try {
fos.write(new byte[16*1024]);
} finally {
fos.close();
}
mklink(link2file, file);
mklink(link2link2file, link2file);
// link2link2dir -> link2dir -> dir
assertTrue(dir.mkdir());
mklink(link2dir, dir);
mklink(link2link2dir, link2dir);
// link2link2nobody -> link2nobody -> <does-not-exist>
mklink(link2nobody, new File(top, "DoesNotExist"));
mklink(link2link2nobody, link2nobody);
}
/**
* Remove files, directories, and sym links used by test.
*/
static void cleanup() throws IOException {
if (file != null)
file.delete();
if (link2file != null)
Files.deleteIfExists(link2file.toPath());
if (link2link2file != null)
Files.deleteIfExists(link2link2file.toPath());
if (dir != null)
dir.delete();
if (link2dir != null)
Files.deleteIfExists(link2dir.toPath());
if (link2link2dir != null)
Files.deleteIfExists(link2link2dir.toPath());
if (link2nobody != null)
Files.deleteIfExists(link2nobody.toPath());
if (link2link2nobody != null)
Files.deleteIfExists(link2link2nobody.toPath());
}
/**
* Creates a sym link source->target
*/
static void mklink(File source, File target) throws IOException {
Files.createSymbolicLink(source.toPath(), target.toPath());
}
/**
* Returns true if the "link" exists and is a sym link.
*/
static boolean isSymLink(File link) {
return Files.isSymbolicLink(link.toPath());
}
/**
* Returns the last modified time of a sym link.
*/
static long lastModifiedOfSymLink(File link) throws IOException {
BasicFileAttributes attrs =
Files.readAttributes(link.toPath(), BasicFileAttributes.class, NOFOLLOW_LINKS);
assertTrue(attrs.isSymbolicLink());
return attrs.lastModifiedTime().toMillis();
}
/**
* Returns true if sym links are supported on the file system where
* "dir" exists.
*/
static boolean supportsSymLinks(File dir) {
Path link = dir.toPath().resolve("link");
Path target = dir.toPath().resolve("target");
try {
Files.createSymbolicLink(link, target);
Files.delete(link);
return true;
} catch (UnsupportedOperationException x) {
return false;
} catch (IOException x) {
return false;
}
}
static void assertTrue(boolean v) {
if (!v) throw new RuntimeException("Test failed");
}
static void assertFalse(boolean v) {
assertTrue(!v);
}
static void header(String h) {
out.println();
out.println();
out.println("-- " + h + " --");
}
/**
* Tests go here.
*/
static void go() throws IOException {
// check setup
assertTrue(file.isFile());
assertTrue(isSymLink(link2file));
assertTrue(isSymLink(link2link2file));
assertTrue(dir.isDirectory());
assertTrue(isSymLink(link2dir));
assertTrue(isSymLink(link2link2dir));
assertTrue(isSymLink(link2nobody));
assertTrue(isSymLink(link2link2nobody));
header("createNewFile");
assertFalse(file.createNewFile());
assertFalse(link2file.createNewFile());
assertFalse(link2link2file.createNewFile());
assertFalse(dir.createNewFile());
assertFalse(link2dir.createNewFile());
assertFalse(link2link2dir.createNewFile());
assertFalse(link2nobody.createNewFile());
assertFalse(link2link2nobody.createNewFile());
header("mkdir");
assertFalse(file.mkdir());
assertFalse(link2file.mkdir());
assertFalse(link2link2file.mkdir());
assertFalse(dir.mkdir());
assertFalse(link2dir.mkdir());
assertFalse(link2link2dir.mkdir());
assertFalse(link2nobody.mkdir());
assertFalse(link2link2nobody.mkdir());
header("delete");
File link = new File(top, "mylink");
try {
mklink(link, file);
assertTrue(link.delete());
assertTrue(!isSymLink(link));
assertTrue(file.exists());
mklink(link, link2file);
assertTrue(link.delete());
assertTrue(!isSymLink(link));
assertTrue(link2file.exists());
mklink(link, dir);
assertTrue(link.delete());
assertTrue(!isSymLink(link));
assertTrue(dir.exists());
mklink(link, link2dir);
assertTrue(link.delete());
assertTrue(!isSymLink(link));
assertTrue(link2dir.exists());
mklink(link, link2nobody);
assertTrue(link.delete());
assertTrue(!isSymLink(link));
assertTrue(isSymLink(link2nobody));
} finally {
Files.deleteIfExists(link.toPath());
}
header("renameTo");
File newlink = new File(top, "newlink");
assertTrue(link2file.renameTo(newlink));
try {
assertTrue(file.exists());
assertTrue(isSymLink(newlink));
assertTrue(!isSymLink(link2file));
} finally {
newlink.renameTo(link2file); // restore link
}
assertTrue(link2dir.renameTo(newlink));
try {
assertTrue(dir.exists());
assertTrue(isSymLink(newlink));
assertTrue(!isSymLink(link2dir));
} finally {
newlink.renameTo(link2dir); // restore link
}
header("list");
final String name = "entry";
File entry = new File(dir, name);
try {
assertTrue(dir.list().length == 0); // directory should be empty
assertTrue(link2dir.list().length == 0);
assertTrue(link2link2dir.list().length == 0);
assertTrue(entry.createNewFile());
assertTrue(dir.list().length == 1);
assertTrue(dir.list()[0].equals(name));
// access directory by following links
assertTrue(link2dir.list().length == 1);
assertTrue(link2dir.list()[0].equals(name));
assertTrue(link2link2dir.list().length == 1);
assertTrue(link2link2dir.list()[0].equals(name));
// files that are not directories
assertTrue(link2file.list() == null);
assertTrue(link2nobody.list() == null);
} finally {
entry.delete();
}
header("isXXX");
assertTrue(file.isFile());
assertTrue(link2file.isFile());
assertTrue(link2link2file.isFile());
assertTrue(dir.isDirectory());
assertTrue(link2dir.isDirectory());
assertTrue(link2link2dir.isDirectory());
// on Windows we test with the DOS hidden attribute set
if (System.getProperty("os.name").startsWith("Windows")) {
DosFileAttributeView view = Files
.getFileAttributeView(file.toPath(), DosFileAttributeView.class);
view.setHidden(true);
try {
assertTrue(file.isHidden());
assertTrue(link2file.isHidden());
assertTrue(link2link2file.isHidden());
} finally {
view.setHidden(false);
}
assertFalse(file.isHidden());
assertFalse(link2file.isHidden());
assertFalse(link2link2file.isHidden());
}
header("length");
long len = file.length();
assertTrue(len > 0L);
// these tests should follow links
assertTrue(link2file.length() == len);
assertTrue(link2link2file.length() == len);
assertTrue(link2nobody.length() == 0L);
header("lastModified / setLastModified");
// need time to diff between link and file
long origLastModified = file.lastModified();
assertTrue(origLastModified != 0L);
try { Thread.sleep(2000); } catch (InterruptedException x) { }
file.setLastModified(System.currentTimeMillis());
long lastModified = file.lastModified();
assertTrue(lastModified != origLastModified);
assertTrue(lastModifiedOfSymLink(link2file) != lastModified);
assertTrue(lastModifiedOfSymLink(link2link2file) != lastModified);
assertTrue(link2file.lastModified() == lastModified);
assertTrue(link2link2file.lastModified() == lastModified);
assertTrue(link2nobody.lastModified() == 0L);
origLastModified = dir.lastModified();
assertTrue(origLastModified != 0L);
dir.setLastModified(0L);
assertTrue(dir.lastModified() == 0L);
assertTrue(link2dir.lastModified() == 0L);
assertTrue(link2link2dir.lastModified() == 0L);
dir.setLastModified(origLastModified);
header("setXXX / canXXX");
assertTrue(file.canRead());
assertTrue(file.canWrite());
assertTrue(link2file.canRead());
assertTrue(link2file.canWrite());
assertTrue(link2link2file.canRead());
assertTrue(link2link2file.canWrite());
if (!Util.isPrivileged() && file.setReadOnly()) {
assertFalse(file.canWrite());
assertFalse(link2file.canWrite());
assertFalse(link2link2file.canWrite());
assertTrue(file.setWritable(true)); // make writable
assertTrue(file.canWrite());
assertTrue(link2file.canWrite());
assertTrue(link2link2file.canWrite());
assertTrue(link2file.setReadOnly()); // make read only
assertFalse(file.canWrite());
assertFalse(link2file.canWrite());
assertFalse(link2link2file.canWrite());
assertTrue(link2link2file.setWritable(true)); // make writable
assertTrue(file.canWrite());
assertTrue(link2file.canWrite());
assertTrue(link2link2file.canWrite());
}
}
public static void main(String[] args) throws IOException {
if (supportsSymLinks(top)) {
try {
setup();
go();
} finally {
cleanup();
}
}
}
}