/*
* 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 8005566
* @summary Unit test for miscellenous methods in java.nio.file.Files
* @library ..
*/
import java.nio.file.*;
import static java.nio.file.Files.*;
import static java.nio.file.LinkOption.*;
import java.nio.file.attribute.*;
import java.io.IOException;
import java.util.*;
public class Misc {
public static void main(String[] args) throws IOException {
Path dir = TestUtil.createTemporaryDirectory();
try {
testCreateDirectories(dir);
testIsHidden(dir);
testIsSameFile(dir);
testFileTypeMethods(dir);
testAccessMethods(dir);
} finally {
TestUtil.removeAll(dir);
}
}
/**
* Tests createDirectories
*/
static void testCreateDirectories(Path tmpdir) throws IOException {
// a no-op
createDirectories(tmpdir);
// create one directory
Path subdir = tmpdir.resolve("a");
createDirectories(subdir);
assertTrue(exists(subdir));
// create parents
subdir = subdir.resolve("b/c/d");
createDirectories(subdir);
assertTrue(exists(subdir));
// existing file is not a directory
Path file = createFile(tmpdir.resolve("x"));
try {
createDirectories(file);
throw new RuntimeException("failure expected");
} catch (FileAlreadyExistsException x) { }
try {
createDirectories(file.resolve("y"));
throw new RuntimeException("failure expected");
} catch (IOException x) { }
}
/**
* Tests isHidden
*/
static void testIsHidden(Path tmpdir) throws IOException {
assertTrue(!isHidden(tmpdir));
Path file = tmpdir.resolve(".foo");
if (System.getProperty("os.name").startsWith("Windows")) {
createFile(file);
try {
setAttribute(file, "dos:hidden", true);
try {
assertTrue(isHidden(file));
} finally {
setAttribute(file, "dos:hidden", false);
}
} finally {
delete(file);
}
} else {
assertTrue(isHidden(file));
}
}
/**
* Tests isSameFile
*/
static void testIsSameFile(Path tmpdir) throws IOException {
Path thisFile = tmpdir.resolve("thisFile");
Path thatFile = tmpdir.resolve("thatFile");
/**
* Test: isSameFile for self
*/
assertTrue(isSameFile(thisFile, thisFile));
/**
* Test: Neither files exist
*/
try {
isSameFile(thisFile, thatFile);
throw new RuntimeException("IOException not thrown");
} catch (IOException x) {
}
try {
isSameFile(thatFile, thisFile);
throw new RuntimeException("IOException not thrown");
} catch (IOException x) {
}
createFile(thisFile);
try {
/**
* Test: One file exists
*/
try {
isSameFile(thisFile, thatFile);
throw new RuntimeException("IOException not thrown");
} catch (IOException x) {
}
try {
isSameFile(thatFile, thisFile);
throw new RuntimeException("IOException not thrown");
} catch (IOException x) {
}
/**
* Test: Both file exists
*/
createFile(thatFile);
try {
assertTrue(!isSameFile(thisFile, thatFile));
assertTrue(!isSameFile(thatFile, thisFile));
} finally {
delete(thatFile);
}
/**
* Test: Symbolic links
*/
if (TestUtil.supportsLinks(tmpdir)) {
createSymbolicLink(thatFile, thisFile);
try {
assertTrue(isSameFile(thisFile, thatFile));
assertTrue(isSameFile(thatFile, thisFile));
} finally {
TestUtil.deleteUnchecked(thatFile);
}
}
} finally {
delete(thisFile);
}
// nulls
try {
isSameFile(thisFile, null);
throw new RuntimeException("NullPointerException expected");
} catch (NullPointerException ignore) { }
try {
isSameFile(null, thatFile);
throw new RuntimeException("NullPointerException expected");
} catch (NullPointerException ignore) { }
}
/**
* Exercise isRegularFile, isDirectory, isSymbolicLink
*/
static void testFileTypeMethods(Path tmpdir) throws IOException {
assertTrue(!isRegularFile(tmpdir));
assertTrue(!isRegularFile(tmpdir, NOFOLLOW_LINKS));
assertTrue(isDirectory(tmpdir));
assertTrue(isDirectory(tmpdir, NOFOLLOW_LINKS));
assertTrue(!isSymbolicLink(tmpdir));
Path file = createFile(tmpdir.resolve("foo"));
try {
assertTrue(isRegularFile(file));
assertTrue(isRegularFile(file, NOFOLLOW_LINKS));
assertTrue(!isDirectory(file));
assertTrue(!isDirectory(file, NOFOLLOW_LINKS));
assertTrue(!isSymbolicLink(file));
if (TestUtil.supportsLinks(tmpdir)) {
Path link = tmpdir.resolve("link");
createSymbolicLink(link, tmpdir);
try {
assertTrue(!isRegularFile(link));
assertTrue(!isRegularFile(link, NOFOLLOW_LINKS));
assertTrue(isDirectory(link));
assertTrue(!isDirectory(link, NOFOLLOW_LINKS));
assertTrue(isSymbolicLink(link));
} finally {
delete(link);
}
createSymbolicLink(link, file);
try {
assertTrue(isRegularFile(link));
assertTrue(!isRegularFile(link, NOFOLLOW_LINKS));
assertTrue(!isDirectory(link));
assertTrue(!isDirectory(link, NOFOLLOW_LINKS));
assertTrue(isSymbolicLink(link));
} finally {
delete(link);
}
createLink(link, file);
try {
assertTrue(isRegularFile(link));
assertTrue(isRegularFile(link, NOFOLLOW_LINKS));
assertTrue(!isDirectory(link));
assertTrue(!isDirectory(link, NOFOLLOW_LINKS));
assertTrue(!isSymbolicLink(link));
} finally {
delete(link);
}
}
} finally {
delete(file);
}
}
/**
* Exercise isReadbale, isWritable, isExecutable, exists, notExists
*/
static void testAccessMethods(Path tmpdir) throws IOException {
// should return false when file does not exist
Path doesNotExist = tmpdir.resolve("doesNotExist");
assertTrue(!isReadable(doesNotExist));
assertTrue(!isWritable(doesNotExist));
assertTrue(!isExecutable(doesNotExist));
assertTrue(!exists(doesNotExist));
assertTrue(notExists(doesNotExist));
Path file = createFile(tmpdir.resolve("foo"));
try {
// files exist
assertTrue(isReadable(file));
assertTrue(isWritable(file));
assertTrue(exists(file));
assertTrue(!notExists(file));
assertTrue(isReadable(tmpdir));
assertTrue(isWritable(tmpdir));
assertTrue(exists(tmpdir));
assertTrue(!notExists(tmpdir));
// sym link exists
if (TestUtil.supportsLinks(tmpdir)) {
Path link = tmpdir.resolve("link");
createSymbolicLink(link, file);
try {
assertTrue(isReadable(link));
assertTrue(isWritable(link));
assertTrue(exists(link));
assertTrue(!notExists(link));
} finally {
delete(link);
}
createSymbolicLink(link, doesNotExist);
try {
assertTrue(!isReadable(link));
assertTrue(!isWritable(link));
assertTrue(!exists(link));
assertTrue(exists(link, NOFOLLOW_LINKS));
assertTrue(notExists(link));
assertTrue(!notExists(link, NOFOLLOW_LINKS));
} finally {
delete(link);
}
}
/**
* Test: Edit ACL to deny WRITE and EXECUTE
*/
if (getFileStore(file).supportsFileAttributeView("acl")) {
AclFileAttributeView view =
getFileAttributeView(file, AclFileAttributeView.class);
UserPrincipal owner = view.getOwner();
List<AclEntry> acl = view.getAcl();
// Insert entry to deny WRITE and EXECUTE
AclEntry entry = AclEntry.newBuilder()
.setType(AclEntryType.DENY)
.setPrincipal(owner)
.setPermissions(AclEntryPermission.WRITE_DATA,
AclEntryPermission.EXECUTE)
.build();
acl.add(0, entry);
view.setAcl(acl);
try {
assertTrue(!isWritable(file));
assertTrue(!isExecutable(file));
} finally {
// Restore ACL
acl.remove(0);
view.setAcl(acl);
}
}
/**
* Test: Windows DOS read-only attribute
*/
if (System.getProperty("os.name").startsWith("Windows")) {
setAttribute(file, "dos:readonly", true);
try {
assertTrue(!isWritable(file));
} finally {
setAttribute(file, "dos:readonly", false);
}
// Read-only attribute does not make direcory read-only
DosFileAttributeView view =
getFileAttributeView(tmpdir, DosFileAttributeView.class);
boolean save = view.readAttributes().isReadOnly();
view.setReadOnly(true);
try {
assertTrue(isWritable(file));
} finally {
view.setReadOnly(save);
}
}
} finally {
delete(file);
}
}
static void assertTrue(boolean okay) {
if (!okay)
throw new RuntimeException("Assertion Failed");
}
}