|
/*
* Copyright (c) 1998, 2017, 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.
*/
/*
@summary Common definitions for general exhaustive pathname tests
@author Mark Reinhold
*/
import java.io.*;
import java.util.*;
import java.nio.file.*;
public class General {
public static boolean debug = false;
private static boolean win32 = (File.separatorChar == '\\');
private static int gensymCounter = 0;
protected static final String userDir = System.getProperty("user.dir");
protected static final String workSubDir = "tmp";
protected static String baseDir = null;
protected static String relative = null;
/* Generate a filename unique to this run */
private static String gensym() {
return "x." + ++gensymCounter;
}
/**
* Create files and folders in the test working directory.
* The purpose is to make sure the test will not go out of
* its user dir when walking the file tree.
*
* @param depth The number of directory levels to be created under
* the user directory. It should be the maximum value
* of the depths passed to checkNames method (including
* direct or indirect calling) in a whole test.
*/
protected static void initTestData(int depth) throws IOException {
File parent = new File(userDir + File.separator + workSubDir);
if (!parent.mkdir()) {
throw new IOException("Fail to create directory: " + parent);
}
for (int i = 0; i < depth; i++) {
File tmp = new File(parent, gensym());
tmp.createNewFile();
tmp = new File(parent, gensym());
if (tmp.mkdir())
parent = tmp;
else
throw new IOException("Fail to create directory, " + tmp);
}
baseDir = parent.getAbsolutePath();
relative = baseDir.substring(userDir.length() + 1);
}
/**
* Find a file in the given subdirectory, or descend into further
* subdirectories, if any, if no file is found here. Return null if no
* file can be found anywhere beneath the given subdirectory.
* @param dir Directory at which we started
* @param subdir Subdirectory that we're exploring
* @param dl Listing of subdirectory
*/
private static String findSomeFile(String dir, String subdir, String[] dl) {
for (int i = 0; i < dl.length; i++) {
File f = new File(subdir, dl[i]);
File df = new File(dir, f.getPath());
if (Files.isRegularFile(df.toPath(), LinkOption.NOFOLLOW_LINKS)) {
return f.getPath();
}
}
for (int i = 0; i < dl.length; i++) {
File f = (subdir.length() == 0) ? new File(dl[i])
: new File(subdir, dl[i]);
File df = new File(dir, f.getPath());
if (Files.isDirectory(df.toPath(), LinkOption.NOFOLLOW_LINKS)) {
String[] dl2 = df.list();
if (dl2 != null) {
String ff = findSomeFile(dir, f.getPath(), dl2);
if (ff != null) return ff;
}
}
}
return null;
}
/**
* Construct a string that names a file in the given directory. If create
* is true, then create a file if none is found, and throw an exception if
* that is not possible; otherwise, return null if no file can be found.
*/
private static String findSomeFile(String dir, boolean create) {
File d = new File(dir);
String[] dl = d.list();
if (dl == null) {
throw new RuntimeException("Can't list " + dir);
}
for (int i = 0; i < dl.length; i++) {
File f = new File(dir, dl[i]);
if (Files.isRegularFile(f.toPath(), LinkOption.NOFOLLOW_LINKS)) {
return dl[i];
}
}
String f = findSomeFile(dir, "", dl);
if (f != null) {
return f;
}
if (create) {
File nf = new File(d, gensym());
OutputStream os;
try {
os = new FileOutputStream(nf);
os.close();
} catch (IOException x) {
throw new RuntimeException("Can't create a file in " + dir);
}
return nf.getName();
}
return null;
}
/**
* Construct a string that names a subdirectory of the given directory.
* If create is true, then create a subdirectory if none is found, and
* throw an exception if that is not possible; otherwise, return null if
* no subdirectory can be found.
*/
private static String findSomeDir(String dir, boolean create) {
File d = new File(dir);
String[] dl = d.list();
if (dl == null) {
throw new RuntimeException("Can't list " + dir);
}
for (int i = 0; i < dl.length; i++) {
File f = new File(d, dl[i]);
if (Files.isDirectory(f.toPath(), LinkOption.NOFOLLOW_LINKS)) {
String[] dl2 = f.list();
if (dl2 == null || dl2.length >= 250) {
/* Heuristic to avoid scanning huge directories */
continue;
}
return dl[i];
}
}
if (create) {
File sd = new File(d, gensym());
if (sd.mkdir()) return sd.getName();
}
return null;
}
/** Construct a string that does not name a file in the given directory */
private static String findNon(String dir) {
File d = new File(dir);
String[] x = new String[] { "foo", "bar", "baz" };
for (int i = 0; i < x.length; i++) {
File f = new File(d, x[i]);
if (!f.exists()) {
return x[i];
}
}
for (int i = 0; i < 1024; i++) {
String n = "xx" + Integer.toString(i);
File f = new File(d, n);
if (!f.exists()) {
return n;
}
}
throw new RuntimeException("Can't find a non-existent file in " + dir);
}
/** Ensure that the named file does not exist */
public static void ensureNon(String fn) {
if ((new File(fn)).exists()) {
throw new RuntimeException("Test path " + fn + " exists");
}
}
/** Tell whether the given character is a "slash" on this platform */
private static boolean isSlash(char x) {
if (x == File.separatorChar) return true;
if (win32 && (x == '/')) return true;
return false;
}
/**
* Trim trailing slashes from the given string, but leave singleton slashes
* alone (they denote root directories)
*/
private static String trimTrailingSlashes(String s) {
int n = s.length();
if (n == 0) return s;
n--;
while ((n > 0) && isSlash(s.charAt(n))) {
if ((n >= 1) && s.charAt(n - 1) == ':') break;
n--;
}
return s.substring(0, n + 1);
}
/** Concatenate two paths, trimming slashes as needed */
private static String pathConcat(String a, String b) {
if (a.length() == 0) return b;
if (b.length() == 0) return a;
if (isSlash(a.charAt(a.length() - 1))
|| isSlash(b.charAt(0))
|| (win32 && (a.charAt(a.length() - 1) == ':'))) {
return a + b;
} else {
return a + File.separatorChar + b;
}
}
/** Hash table of input pathnames, used to detect duplicates */
private static Hashtable<String, String> checked = new Hashtable<>();
/**
* Check the given pathname. Its canonical pathname should be the given
* answer. If the path names a file that exists and is readable, then
* FileInputStream and RandomAccessFile should both be able to open it.
*/
public static void check(String answer, String path) throws IOException {
String ans = trimTrailingSlashes(answer);
if (path.length() == 0) return;
if (checked.get(path) != null) {
System.err.println("DUP " + path);
return;
}
checked.put(path, path);
String cpath;
try {
File f = new File(path);
cpath = f.getCanonicalPath();
if (f.exists() && f.isFile() && f.canRead()) {
InputStream in = new FileInputStream(path);
in.close();
RandomAccessFile raf = new RandomAccessFile(path, "r");
raf.close();
}
} catch (IOException x) {
System.err.println(ans + " <-- " + path + " ==> " + x);
if (debug) return;
else throw x;
}
if (cpath.equals(ans)) {
System.err.println(ans + " <== " + path);
} else {
System.err.println(ans + " <-- " + path + " ==> " + cpath + " MISMATCH");
if (!debug) {
throw new RuntimeException("Mismatch: " + path + " ==> " + cpath +
", should be " + ans);
}
}
}
/*
* The following three mutually-recursive methods generate and check a tree
* of filenames of arbitrary depth. Each method has (at least) these
* arguments:
*
* int depth Remaining tree depth
* boolean create Controls whether test files and directories
* will be created as needed
* String ans Expected answer for the check method (above)
* String ask Input pathname to be passed to the check method
*/
/** Check a single slash case, plus its children */
private static void checkSlash(int depth, boolean create,
String ans, String ask, String slash)
throws Exception
{
check(ans, ask + slash);
checkNames(depth, create,
ans.endsWith(File.separator) ? ans : ans + File.separator,
ask + slash);
}
/** Check slash cases for the given ask string */
public static void checkSlashes(int depth, boolean create,
String ans, String ask)
throws Exception
{
check(ans, ask);
if (depth == 0) return;
checkSlash(depth, create, ans, ask, "/");
checkSlash(depth, create, ans, ask, "//");
checkSlash(depth, create, ans, ask, "///");
if (win32) {
checkSlash(depth, create, ans, ask, "\\");
checkSlash(depth, create, ans, ask, "\\\\");
checkSlash(depth, create, ans, ask, "\\/");
checkSlash(depth, create, ans, ask, "/\\");
checkSlash(depth, create, ans, ask, "\\\\\\");
}
}
/** Check name cases for the given ask string */
public static void checkNames(int depth, boolean create,
String ans, String ask)
throws Exception
{
int d = depth - 1;
File f = new File(ans);
String n;
/* Normal name */
if (f.exists()) {
if (Files.isDirectory(f.toPath(), LinkOption.NOFOLLOW_LINKS) && f.list() != null) {
if ((n = findSomeFile(ans, create)) != null)
checkSlashes(d, create, ans + n, ask + n);
if ((n = findSomeDir(ans, create)) != null)
checkSlashes(d, create, ans + n, ask + n);
}
n = findNon(ans);
checkSlashes(d, create, ans + n, ask + n);
} else {
n = "foo" + depth;
checkSlashes(d, create, ans + n, ask + n);
}
/* "." */
checkSlashes(d, create, trimTrailingSlashes(ans), ask + ".");
/* ".." */
if ((n = f.getParent()) != null) {
String n2;
if (win32
&& ((n2 = f.getParentFile().getParent()) != null)
&& n2.equals("\\\\")) {
/* Win32 resolves \\foo\bar\.. to \\foo\bar */
checkSlashes(d, create, ans, ask + "..");
} else {
checkSlashes(d, create, n, ask + "..");
}
}
else {
if (win32)
checkSlashes(d, create, ans, ask + "..");
else {
// Fix for 4237875. We must ensure that we are sufficiently
// deep in the path hierarchy to test parents this high up
File thisPath = new File(ask);
File nextPath = new File(ask + "..");
if (!thisPath.getCanonicalPath().equals(nextPath.getCanonicalPath()))
checkSlashes(d, create, ans + "..", ask + "..");
}
}
}
}
¤ Dauer der Verarbeitung: 0.22 Sekunden
(vorverarbeitet)
¤
|
Haftungshinweis
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.
|
