/*
* Copyright (c) 2008, 2011, 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 4313887 6838333
* @summary Unit test for java.nio.file.attribute.PosixFileAttributeView
* @library ../..
*/
import java.nio.file.*;
import static java.nio.file.LinkOption.*;
import java.nio.file.attribute.*;
import java.io.IOException;
import java.util.*;
/**
* Unit test for PosixFileAttributeView, passing silently if this attribute
* view is not available.
*/
public class Basic {
/**
* Use view to update permission to the given mode and check that the
* permissions have been updated.
*/
static void testPermissions(Path file, String mode) throws IOException {
System.out.format("change mode: %s\n", mode);
Set<PosixFilePermission> perms = PosixFilePermissions.fromString(mode);
// change permissions and re-read them.
Files.setPosixFilePermissions(file, perms);
Set<PosixFilePermission> current = Files.getPosixFilePermissions(file);
if (!current.equals(perms)) {
throw new RuntimeException("Actual permissions: " +
PosixFilePermissions.toString(current) + ", expected: " +
PosixFilePermissions.toString(perms));
}
// repeat test using setAttribute/getAttribute
Files.setAttribute(file, "posix:permissions", perms);
current = (Set<PosixFilePermission>)Files.getAttribute(file, "posix:permissions");
if (!current.equals(perms)) {
throw new RuntimeException("Actual permissions: " +
PosixFilePermissions.toString(current) + ", expected: " +
PosixFilePermissions.toString(perms));
}
}
/**
* Check that the actual permissions of a file match or make it more
* secure than requested
*/
static void checkSecure(Set<PosixFilePermission> requested,
Set<PosixFilePermission> actual)
{
for (PosixFilePermission perm: actual) {
if (!requested.contains(perm)) {
throw new RuntimeException("Actual permissions: " +
PosixFilePermissions.toString(actual) + ", requested: " +
PosixFilePermissions.toString(requested) +
" - file is less secure than requested");
}
}
}
/**
* Create file with given mode and check that the file is created with a
* mode that is not less secure
*/
static void createWithPermissions(Path file,
String mode)
throws IOException
{
Set<PosixFilePermission> requested = PosixFilePermissions.fromString(mode);
FileAttribute<Set<PosixFilePermission>> attr =
PosixFilePermissions.asFileAttribute(requested);
System.out.format("create file with mode: %s\n", mode);
Files.createFile(file, attr);
try {
checkSecure(requested,
Files.getFileAttributeView(file, PosixFileAttributeView.class)
.readAttributes()
.permissions());
} finally {
Files.delete(file);
}
System.out.format("create directory with mode: %s\n", mode);
Files.createDirectory(file, attr);
try {
checkSecure(requested,
Files.getFileAttributeView(file, PosixFileAttributeView.class)
.readAttributes()
.permissions());
} finally {
Files.delete(file);
}
}
/**
* Test the setPermissions/permissions methods.
*/
static void permissionTests(Path dir)
throws IOException
{
System.out.println("-- Permission Tests --");
// create file and test updating and reading its permissions
Path file = dir.resolve("foo");
System.out.format("create %s\n", file);
Files.createFile(file);
try {
// get initial permissions so that we can restore them later
PosixFileAttributeView view =
Files.getFileAttributeView(file, PosixFileAttributeView.class);
Set<PosixFilePermission> save = view.readAttributes()
.permissions();
// test various modes
try {
testPermissions(file, "---------");
testPermissions(file, "r--------");
testPermissions(file, "-w-------");
testPermissions(file, "--x------");
testPermissions(file, "rwx------");
testPermissions(file, "---r-----");
testPermissions(file, "----w----");
testPermissions(file, "-----x---");
testPermissions(file, "---rwx---");
testPermissions(file, "------r--");
testPermissions(file, "-------w-");
testPermissions(file, "--------x");
testPermissions(file, "------rwx");
testPermissions(file, "r--r-----");
testPermissions(file, "r--r--r--");
testPermissions(file, "rw-rw----");
testPermissions(file, "rwxrwx---");
testPermissions(file, "rw-rw-r--");
testPermissions(file, "r-xr-x---");
testPermissions(file, "r-xr-xr-x");
testPermissions(file, "rwxrwxrwx");
} finally {
view.setPermissions(save);
}
} finally {
Files.delete(file);
}
// create link (to file that doesn't exist) and test reading of
// permissions
if (TestUtil.supportsLinks(dir)) {
Path link = dir.resolve("link");
System.out.format("create link %s\n", link);
Files.createSymbolicLink(link, file);
try {
PosixFileAttributes attrs =
Files.getFileAttributeView(link,
PosixFileAttributeView.class,
NOFOLLOW_LINKS)
.readAttributes();
if (!attrs.isSymbolicLink()) {
throw new RuntimeException("not a link");
}
} finally {
Files.delete(link);
}
}
System.out.println("OKAY");
}
/**
* Test creating a file and directory with initial permissios
*/
static void createTests(Path dir)
throws IOException
{
System.out.println("-- Create Tests --");
Path file = dir.resolve("foo");
createWithPermissions(file, "---------");
createWithPermissions(file, "r--------");
createWithPermissions(file, "-w-------");
createWithPermissions(file, "--x------");
createWithPermissions(file, "rwx------");
createWithPermissions(file, "---r-----");
createWithPermissions(file, "----w----");
createWithPermissions(file, "-----x---");
createWithPermissions(file, "---rwx---");
createWithPermissions(file, "------r--");
createWithPermissions(file, "-------w-");
createWithPermissions(file, "--------x");
createWithPermissions(file, "------rwx");
createWithPermissions(file, "r--r-----");
createWithPermissions(file, "r--r--r--");
createWithPermissions(file, "rw-rw----");
createWithPermissions(file, "rwxrwx---");
createWithPermissions(file, "rw-rw-r--");
createWithPermissions(file, "r-xr-x---");
createWithPermissions(file, "r-xr-xr-x");
createWithPermissions(file, "rwxrwxrwx");
System.out.println("OKAY");
}
/**
* Test setOwner/setGroup methods - this test simply exercises the
* methods to avoid configuration.
*/
static void ownerTests(Path dir)
throws IOException
{
System.out.println("-- Owner Tests --");
Path file = dir.resolve("gus");
System.out.format("create %s\n", file);
Files.createFile(file);
try {
// read attributes of directory to get owner/group
PosixFileAttributeView view =
Files.getFileAttributeView(file, PosixFileAttributeView.class);
PosixFileAttributes attrs = view.readAttributes();
// set to existing owner/group
view.setOwner(attrs.owner());
view.setGroup(attrs.group());
// repeat test using set/getAttribute
UserPrincipal owner = (UserPrincipal)Files.getAttribute(file, "posix:owner");
Files.setAttribute(file, "posix:owner", owner);
UserPrincipal group = (UserPrincipal)Files.getAttribute(file, "posix:group");
Files.setAttribute(file, "posix:group", group);
} finally {
Files.delete(file);
}
System.out.println("OKAY");
}
/**
* Test the lookupPrincipalByName/lookupPrincipalByGroupName methods
*/
static void lookupPrincipalTests(Path dir)
throws IOException
{
System.out.println("-- Lookup UserPrincipal Tests --");
UserPrincipalLookupService lookupService = dir.getFileSystem()
.getUserPrincipalLookupService();
// read attributes of directory to get owner/group
PosixFileAttributes attrs = Files.readAttributes(dir, PosixFileAttributes.class);
// lookup owner and check it matches file's owner
System.out.format("lookup: %s\n", attrs.owner().getName());
try {
UserPrincipal owner = lookupService.lookupPrincipalByName(attrs.owner().getName());
if (owner instanceof GroupPrincipal)
throw new RuntimeException("owner is a group?");
if (!owner.equals(attrs.owner()))
throw new RuntimeException("owner different from file owner");
} catch (UserPrincipalNotFoundException x) {
System.out.println("user not found - test skipped");
}
// lookup group and check it matches file's group-owner
System.out.format("lookup group: %s\n", attrs.group().getName());
try {
GroupPrincipal group = lookupService.lookupPrincipalByGroupName(attrs.group().getName());
if (!group.equals(attrs.group()))
throw new RuntimeException("group different from file group-owner");
} catch (UserPrincipalNotFoundException x) {
System.out.println("group not found - test skipped");
}
// test that UserPrincipalNotFoundException is thrown
String invalidPrincipal = "scumbag99";
try {
System.out.format("lookup: %s\n", invalidPrincipal);
lookupService.lookupPrincipalByName(invalidPrincipal);
throw new RuntimeException("'" + invalidPrincipal + "' is a valid user?");
} catch (UserPrincipalNotFoundException x) {
}
try {
System.out.format("lookup group: %s\n", invalidPrincipal);
lookupService.lookupPrincipalByGroupName("idonotexist");
throw new RuntimeException("'" + invalidPrincipal + "' is a valid group?");
} catch (UserPrincipalNotFoundException x) {
}
System.out.println("OKAY");
}
/**
* Test various exceptions are thrown as expected
*/
@SuppressWarnings("unchecked")
static void exceptionsTests(Path dir)
throws IOException
{
System.out.println("-- Exceptions --");
PosixFileAttributeView view =
Files.getFileAttributeView(dir,PosixFileAttributeView.class);
// NullPointerException
try {
view.setOwner(null);
throw new RuntimeException("NullPointerException not thrown");
} catch (NullPointerException x) {
}
try {
view.setGroup(null);
throw new RuntimeException("NullPointerException not thrown");
} catch (NullPointerException x) {
}
UserPrincipalLookupService lookupService = dir.getFileSystem()
.getUserPrincipalLookupService();
try {
lookupService.lookupPrincipalByName(null);
throw new RuntimeException("NullPointerException not thrown");
} catch (NullPointerException x) {
}
try {
lookupService.lookupPrincipalByGroupName(null);
throw new RuntimeException("NullPointerException not thrown");
} catch (NullPointerException x) {
}
try {
view.setPermissions(null);
throw new RuntimeException("NullPointerException not thrown");
} catch (NullPointerException x) {
}
try {
Set<PosixFilePermission> perms = new HashSet<>();
perms.add(null);
view.setPermissions(perms);
throw new RuntimeException("NullPointerException not thrown");
} catch (NullPointerException x) {
}
// ClassCastException
try {
Set perms = new HashSet(); // raw type
perms.add(new Object());
view.setPermissions(perms);
throw new RuntimeException("ClassCastException not thrown");
} catch (ClassCastException x) {
}
System.out.println("OKAY");
}
public static void main(String[] args) throws IOException {
Path dir = TestUtil.createTemporaryDirectory();
try {
if (!Files.getFileStore(dir).supportsFileAttributeView("posix")) {
System.out.println("PosixFileAttributeView not supported");
return;
}
permissionTests(dir);
createTests(dir);
ownerTests(dir);
lookupPrincipalTests(dir);
exceptionsTests(dir);
} finally {
TestUtil.removeAll(dir);
}
}
}