test/jdk/java/io/pathNames/General.java - platform/libcore - Git at Google

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