/* * 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 perms = PosixFilePermissions.fromString(mode); // change permissions and re-read them. Files.setPosixFilePermissions(file, perms); Set 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)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 requested, Set 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 requested = PosixFilePermissions.fromString(mode); FileAttribute> 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 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 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); } } }