test/jdk/java/io/pathNames/General.java

/*
 * 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 + "..");
            }
        }
    }
}