Basic.java revision 893:f06f30b29f36 
1/*
2 * Copyright 2008-2009 Sun Microsystems, Inc.  All Rights Reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
20 * CA 95054 USA or visit www.sun.com if you need additional information or
21 * have any questions.
22 */
23
24/* @test
25 * @bug 4313887
26 * @summary Unit test for java.nio.file.attribute.PosixFileAttributeView
27 * @library ../..
28 */
29
30import java.nio.file.*;
31import static java.nio.file.LinkOption.*;
32import java.nio.file.attribute.*;
33import java.io.IOException;
34import java.util.*;
35
36/**
37 * Unit test for PosixFileAttributeView, passing silently if this attribute
38 * view is not available.
39 */
40
41public class Basic {
42
43    /**
44     * Use view to update permission to the given mode and check that the
45     * permissions have been updated.
46     */
47    static void testPermissions(PosixFileAttributeView view, String mode)
48        throws IOException
49    {
50        System.out.format("change mode: %s\n", mode);
51        Set<PosixFilePermission> perms = PosixFilePermissions.fromString(mode);
52
53        // change permissions and re-read them.
54        view.setPermissions(perms);
55        Set<PosixFilePermission> current = view.readAttributes().permissions();
56        if (!current.equals(perms)) {
57            throw new RuntimeException("Actual permissions: " +
58                PosixFilePermissions.toString(current) + ", expected: " +
59                PosixFilePermissions.toString(perms));
60        }
61
62        // repeat test using setAttribute/getAttribute
63        view.setAttribute("permissions", perms);
64        current = (Set<PosixFilePermission>)view.getAttribute("permissions");
65        if (!current.equals(perms)) {
66            throw new RuntimeException("Actual permissions: " +
67                PosixFilePermissions.toString(current) + ", expected: " +
68                PosixFilePermissions.toString(perms));
69        }
70    }
71
72    /**
73     * Check that the actual permissions of a file match or make it more
74     * secure than requested
75     */
76    static void checkSecure(Set<PosixFilePermission> requested,
77                            Set<PosixFilePermission> actual)
78    {
79        for (PosixFilePermission perm: actual) {
80            if (!requested.contains(perm)) {
81                throw new RuntimeException("Actual permissions: " +
82                    PosixFilePermissions.toString(actual) + ", requested: " +
83                    PosixFilePermissions.toString(requested) +
84                    " - file is less secure than requested");
85            }
86        }
87    }
88
89    /**
90     * Create file with given mode and check that the file is created with a
91     * mode that is not less secure
92     */
93    static void createWithPermissions(Path file,
94                                      String mode)
95        throws IOException
96    {
97        Set<PosixFilePermission> requested = PosixFilePermissions.fromString(mode);
98        FileAttribute<Set<PosixFilePermission>> attr =
99            PosixFilePermissions.asFileAttribute(requested);
100        System.out.format("create file with mode: %s\n", mode);
101
102        EnumSet<StandardOpenOption> options = EnumSet.of(StandardOpenOption.CREATE_NEW,
103            StandardOpenOption.WRITE);
104        file.newOutputStream(options, attr).close();
105        try {
106            checkSecure(requested,  file
107                .getFileAttributeView(PosixFileAttributeView.class)
108                .readAttributes()
109                .permissions());
110        } finally {
111            file.delete(false);
112        }
113
114        System.out.format("create directory with mode: %s\n", mode);
115        file.createDirectory(attr);
116        try {
117            checkSecure(requested,  file
118                .getFileAttributeView(PosixFileAttributeView.class)
119                .readAttributes()
120                .permissions());
121        } finally {
122            file.delete(false);
123        }
124    }
125
126    /**
127     * Test the setPermissions/permissions methods.
128     */
129    static void permissionTests(Path dir)
130        throws IOException
131    {
132        System.out.println("-- Permission Tests  --");
133
134        // create file and test updating and reading its permissions
135        Path file = dir.resolve("foo");
136        System.out.format("create %s\n", file);
137        file.newOutputStream().close();
138        try {
139            // get initial permissions so that we can restore them later
140            PosixFileAttributeView view = file
141                .getFileAttributeView(PosixFileAttributeView.class);
142            Set<PosixFilePermission> save = view.readAttributes()
143                .permissions();
144
145            // test various modes
146            try {
147                testPermissions(view, "---------");
148                testPermissions(view, "r--------");
149                testPermissions(view, "-w-------");
150                testPermissions(view, "--x------");
151                testPermissions(view, "rwx------");
152                testPermissions(view, "---r-----");
153                testPermissions(view, "----w----");
154                testPermissions(view, "-----x---");
155                testPermissions(view, "---rwx---");
156                testPermissions(view, "------r--");
157                testPermissions(view, "-------w-");
158                testPermissions(view, "--------x");
159                testPermissions(view, "------rwx");
160                testPermissions(view, "r--r-----");
161                testPermissions(view, "r--r--r--");
162                testPermissions(view, "rw-rw----");
163                testPermissions(view, "rwxrwx---");
164                testPermissions(view, "rw-rw-r--");
165                testPermissions(view, "r-xr-x---");
166                testPermissions(view, "r-xr-xr-x");
167                testPermissions(view, "rwxrwxrwx");
168            } finally {
169                view.setPermissions(save);
170            }
171        } finally {
172            file.delete(false);
173        }
174
175        // create link (to file that doesn't exist) and test reading of
176        // permissions
177        if (TestUtil.supportsLinks(dir)) {
178            Path link = dir.resolve("link");
179            System.out.format("create link %s\n", link);
180            link.createSymbolicLink(file);
181            try {
182                PosixFileAttributes attrs = Attributes
183                    .readPosixFileAttributes(link, NOFOLLOW_LINKS);
184                if (!attrs.isSymbolicLink()) {
185                    throw new RuntimeException("not a link");
186                }
187            } finally {
188                link.delete(false);
189            }
190        }
191
192        System.out.println("OKAY");
193    }
194
195    /**
196     * Test creating a file and directory with initial permissios
197     */
198    static void createTests(Path dir)
199        throws IOException
200    {
201        System.out.println("-- Create Tests  --");
202
203        Path file = dir.resolve("foo");
204
205        createWithPermissions(file, "---------");
206        createWithPermissions(file, "r--------");
207        createWithPermissions(file, "-w-------");
208        createWithPermissions(file, "--x------");
209        createWithPermissions(file, "rwx------");
210        createWithPermissions(file, "---r-----");
211        createWithPermissions(file, "----w----");
212        createWithPermissions(file, "-----x---");
213        createWithPermissions(file, "---rwx---");
214        createWithPermissions(file, "------r--");
215        createWithPermissions(file, "-------w-");
216        createWithPermissions(file, "--------x");
217        createWithPermissions(file, "------rwx");
218        createWithPermissions(file, "r--r-----");
219        createWithPermissions(file, "r--r--r--");
220        createWithPermissions(file, "rw-rw----");
221        createWithPermissions(file, "rwxrwx---");
222        createWithPermissions(file, "rw-rw-r--");
223        createWithPermissions(file, "r-xr-x---");
224        createWithPermissions(file, "r-xr-xr-x");
225        createWithPermissions(file, "rwxrwxrwx");
226
227        System.out.println("OKAY");
228    }
229
230    /**
231     * Test setOwner/setGroup methods - this test simply exercises the
232     * methods to avoid configuration.
233     */
234    static void ownerTests(Path dir)
235        throws IOException
236    {
237        System.out.println("-- Owner Tests  --");
238
239        Path file = dir.resolve("gus");
240        System.out.format("create %s\n", file);
241
242        file.newOutputStream().close();
243        try {
244
245            // read attributes of directory to get owner/group
246            PosixFileAttributeView view = file
247                .getFileAttributeView(PosixFileAttributeView.class);
248            PosixFileAttributes attrs = view.readAttributes();
249
250            // set to existing owner/group
251            view.setOwner(attrs.owner());
252            view.setGroup(attrs.group());
253
254            // repeat test using setAttribute
255            Map<String,?> map = view.readAttributes("owner","group");
256            view.setAttribute("owner", map.get("owner"));
257            view.setAttribute("group", map.get("group"));
258
259        } finally {
260            file.delete(false);
261        }
262
263        System.out.println("OKAY");
264    }
265
266    /**
267     * Test the lookupPrincipalByName/lookupPrincipalByGroupName methods
268     */
269    static void lookupPrincipalTests(Path dir)
270        throws IOException
271    {
272        System.out.println("-- Lookup UserPrincipal Tests --");
273
274        UserPrincipalLookupService lookupService = dir.getFileSystem()
275            .getUserPrincipalLookupService();
276
277        // read attributes of directory to get owner/group
278        PosixFileAttributes attrs = Attributes.readPosixFileAttributes(dir);
279
280        // lookup owner and check it matches file's owner
281        System.out.format("lookup: %s\n", attrs.owner().getName());
282        try {
283            UserPrincipal owner = lookupService.lookupPrincipalByName(attrs.owner().getName());
284            if (owner instanceof GroupPrincipal)
285                throw new RuntimeException("owner is a group?");
286            if (!owner.equals(attrs.owner()))
287                throw new RuntimeException("owner different from file owner");
288        } catch (UserPrincipalNotFoundException x) {
289            System.out.println("user not found - test skipped");
290        }
291
292        // lookup group and check it matches file's group-owner
293        System.out.format("lookup group: %s\n", attrs.group().getName());
294        try {
295            GroupPrincipal group = lookupService.lookupPrincipalByGroupName(attrs.group().getName());
296            if (!group.equals(attrs.group()))
297                throw new RuntimeException("group different from file group-owner");
298        } catch (UserPrincipalNotFoundException x) {
299            System.out.println("group not found - test skipped");
300        }
301
302        // test that UserPrincipalNotFoundException is thrown
303        String invalidPrincipal = "scumbag99";
304        try {
305            System.out.format("lookup: %s\n", invalidPrincipal);
306            lookupService.lookupPrincipalByName(invalidPrincipal);
307            throw new RuntimeException("'" + invalidPrincipal + "' is a valid user?");
308        } catch (UserPrincipalNotFoundException x) {
309        }
310        try {
311            System.out.format("lookup group: %s\n", invalidPrincipal);
312            lookupService.lookupPrincipalByGroupName("idonotexist");
313            throw new RuntimeException("'" + invalidPrincipal + "' is a valid group?");
314        } catch (UserPrincipalNotFoundException x) {
315        }
316        System.out.println("OKAY");
317    }
318
319    /**
320     * Test various exceptions are thrown as expected
321     */
322    @SuppressWarnings("unchecked")
323    static void exceptionsTests(Path dir)
324        throws IOException
325    {
326        System.out.println("-- Exceptions --");
327
328        PosixFileAttributeView view = dir
329            .getFileAttributeView(PosixFileAttributeView.class);
330
331        // NullPointerException
332        try {
333            view.setOwner(null);
334            throw new RuntimeException("NullPointerException not thrown");
335        } catch (NullPointerException x) {
336        }
337        try {
338            view.setGroup(null);
339            throw new RuntimeException("NullPointerException not thrown");
340        } catch (NullPointerException x) {
341        }
342
343        UserPrincipalLookupService lookupService = dir.getFileSystem()
344            .getUserPrincipalLookupService();
345        try {
346            lookupService.lookupPrincipalByName(null);
347            throw new RuntimeException("NullPointerException not thrown");
348        } catch (NullPointerException x) {
349        }
350        try {
351            lookupService.lookupPrincipalByGroupName(null);
352            throw new RuntimeException("NullPointerException not thrown");
353        } catch (NullPointerException x) {
354        }
355        try {
356            view.setPermissions(null);
357            throw new RuntimeException("NullPointerException not thrown");
358        } catch (NullPointerException x) {
359        }
360        try {
361            Set<PosixFilePermission> perms = new HashSet<PosixFilePermission>();
362            perms.add(null);
363            view.setPermissions(perms);
364            throw new RuntimeException("NullPointerException not thrown");
365        }  catch (NullPointerException x) {
366        }
367
368        // ClassCastException
369        try {
370            Set perms = new HashSet();  // raw type
371            perms.add(new Object());
372            view.setPermissions(perms);
373            throw new RuntimeException("ClassCastException not thrown");
374        }  catch (ClassCastException x) {
375        }
376
377        System.out.println("OKAY");
378    }
379
380    public static void main(String[] args) throws IOException {
381        Path dir = TestUtil.createTemporaryDirectory();
382        try {
383            if (!dir.getFileStore().supportsFileAttributeView("posix")) {
384                System.out.println("PosixFileAttributeView not supported");
385                return;
386            }
387
388            permissionTests(dir);
389            createTests(dir);
390            ownerTests(dir);
391            lookupPrincipalTests(dir);
392            exceptionsTests(dir);
393
394        } finally {
395            TestUtil.removeAll(dir);
396        }
397    }
398}
399