xref: /external/apache-harmony/luni/src/test/api/unix/org/apache/harmony/luni/tests/java/io/UnixFileTest.java

/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package org.apache.harmony.luni.tests.java.io;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

import junit.framework.TestCase;

/**
 * Please note that this case can only be passed on Linux due to some file
 * system dependent reason.
 *
 */
public class UnixFileTest extends TestCase {
	private boolean root = false;

	private File testFile;

	private File testDir;

	private static final int TOTAL_SPACE_NUM = 0;

	private static final int FREE_SPACE_NUM = 1;

	private static final int USABLE_SPACE_NUM = 2;

	private static class ConsoleResulter extends Thread {
		Process proc;

		InputStream is;

		String resStr;

		ConsoleResulter(Process p, InputStream in) {
			proc = p;
			is = in;
		}

		@Override
		public void run() {
			StringBuffer result = new StringBuffer();
			synchronized (result) {
				try {
					BufferedReader br = new BufferedReader(
							new InputStreamReader(is));
					String line;
					while ((line = br.readLine()) != null) {
						result.append(line);
					}
					if (result.length() != 0) {
						resStr = result.toString();
					}

					br.close();
				} catch (IOException ioe) {
					result = null;
				}
				synchronized (proc) {
					proc.notifyAll();
				}
			}
		}
	}

	private static long getLinuxSpace(int index, File file) throws Exception {
		long[] result = new long[3];
		String par = file.getAbsolutePath();
		String osName = System.getProperty("os.name");
		// in case the test case will run under other OS.
		if (osName.toLowerCase().indexOf("linux") != -1) {
			String[] cmd = new String[2];
			cmd[0] = "df";
			cmd[1] = par; // get the total space of file
			Runtime rt = Runtime.getRuntime();

			Process proc = rt.exec(cmd);
			// get output from the command
			ConsoleResulter outputResult = new ConsoleResulter(proc, proc
					.getInputStream());

			synchronized (proc) {
				outputResult.start();
				proc.wait();
			}
			// If there is no error, obtain the result
			if (outputResult.resStr != null) {
				// exit the subprocess safely
				proc.waitFor();

				// filter unnecessary information
				String[] txtResult = outputResult.resStr
						.split("\\D|\\p{javaLowerCase}|\\p{javaUpperCase}");
				for (int i = 0, j = 0; i < txtResult.length; i++) {
					if (txtResult[i].length() > 3) {
						result[j++] = Long.parseLong(txtResult[i]) * 1024L;
					}
				}
			}
		}

		// calculate free spaces according to df command
		result[1] = result[0] - result[1];
		return result[index];
	}

	/**
	 * @tests java.io.File#canExecute()
	 *
	 * @since 1.6
	 */
	public void test_canExecute() {
		assertFalse(testFile.canExecute());
		assertTrue(testFile.setExecutable(true, false));
		assertTrue(testFile.canExecute());
		assertTrue(testFile.setExecutable(true, true));
		assertTrue(testFile.canExecute());

		assertTrue(testFile.setExecutable(false, false));
		assertFalse(testFile.canExecute());
		assertTrue(testFile.setExecutable(false, true));
		assertFalse(testFile.canExecute());

		assertTrue(testFile.setExecutable(true, false));
		assertTrue(testFile.canExecute());

		// tests directory
		assertTrue(testDir.canExecute());
		assertTrue(testDir.setExecutable(false, true));
		if (root) {
			assertTrue(testDir.canExecute());
		} else {
			assertFalse(testDir.canExecute());
		}
		assertTrue(testDir.setExecutable(true, false));
		assertTrue(testDir.canExecute());
	}

	/**
	 * @tests java.io.File#getFreeSpace()
	 *
	 * @since 1.6
	 */
	public void test_getFreeSpace() throws Exception {
		long fileSpace = getLinuxSpace(FREE_SPACE_NUM, testFile);
		long dirSpace = getLinuxSpace(FREE_SPACE_NUM, testDir);
		// in case we cannot fetch the value from command line
		if (fileSpace > 0) {
			assertEquals(fileSpace, testFile.getFreeSpace());
		}

		if (dirSpace > 0) {
			assertEquals(dirSpace, testDir.getFreeSpace());
		}
	}

	/**
	 * @tests java.io.File#getTotalSpace()
	 *
	 * @since 1.6
	 */
	public void test_getTotalSpace() throws Exception {
		long fileSpace = getLinuxSpace(TOTAL_SPACE_NUM, testFile);
		long dirSpace = getLinuxSpace(TOTAL_SPACE_NUM, testDir);
		if (fileSpace > 0) {
			assertEquals(fileSpace, testFile.getTotalSpace());
		}
		if (dirSpace > 0) {
			assertEquals(dirSpace, testDir.getTotalSpace());
		}
	}

	/**
	 * @tests java.io.File#getUsableSpace()
	 *
	 * @since 1.6
	 */
	public void test_getUsableSpace() throws Exception {
		long fileSpace = getLinuxSpace(USABLE_SPACE_NUM, testFile);
		long dirSpace = getLinuxSpace(USABLE_SPACE_NUM, testDir);
		if (fileSpace > 0) {
			assertEquals(fileSpace, testFile.getUsableSpace());
		}
		if (dirSpace > 0) {
			assertEquals(dirSpace, testDir.getUsableSpace());
		}
	}

	/**
	 * @tests java.io.File#setExecutable(boolean, boolean)
	 *
	 * @since 1.6
	 */
	public void test_setExecutableZZ() {
		// setExecutable(true, true/false)
		assertFalse(testFile.canExecute());
		assertTrue(testFile.setExecutable(true, false));
		assertTrue(testFile.canExecute());
		assertTrue(testFile.setExecutable(true, true));
		assertTrue(testFile.canExecute());

		// setExecutable(false, true/false)
		assertTrue(testFile.setExecutable(false, true));
		if (root) {
			assertTrue(testFile.canExecute());
		} else {
			assertFalse(testFile.canExecute());
		}
		assertTrue(testFile.setExecutable(false, false));
		assertFalse(testFile.canExecute());

		// tests directory
		assertTrue(testDir.canExecute());
		assertTrue(testDir.setExecutable(false, true));
		if (root) {
			assertTrue(testDir.canExecute());
		} else {
			assertFalse(testDir.canExecute());
		}
		assertTrue(testDir.setExecutable(false, false));
		if (root) {
			assertTrue(testDir.canExecute());
		} else {
			assertFalse(testDir.canExecute());
		}

		assertTrue(testDir.setExecutable(true, true));
		assertTrue(testDir.canExecute());
		assertTrue(testDir.setExecutable(true, false));
		assertTrue(testDir.canExecute());
	}

	/**
	 * @tests java.io.File#setExecutable(boolean)
	 *
	 * @since 1.6
	 */
	public void test_setExecutableZ() {
		// So far this method only deals with the situation that the user is the
		// owner of the file
		assertTrue(testFile.setExecutable(true));
		assertTrue(testFile.canExecute());
		assertTrue(testFile.setExecutable(false));
		assertFalse(testFile.canExecute());
		assertTrue(testFile.setExecutable(true));

		// tests directory
		assertTrue(testDir.canExecute());
		assertTrue(testDir.setExecutable(false));
		if (root) {
			assertTrue(testDir.canExecute());
		} else {
			assertFalse(testDir.canExecute());
		}
		assertTrue(testDir.setExecutable(true));
		assertTrue(testDir.canExecute());
	}

	/**
	 * @tests java.io.File#setReadable(boolean, boolean)
	 *
	 * @since 1.6
	 */
	public void test_setReadableZZ() throws Exception {
		// setReadable(false, false/true) succeeds on Linux
		// However, canRead() always returns true when the user is 'root'.
		assertTrue(testFile.canRead());
		assertTrue(testFile.setReadable(false, false));
		if (root) {
			assertTrue(testFile.canRead());
		} else {
			assertFalse(testFile.canRead());
		}
		assertTrue(testFile.setReadable(false, true));
		if (root) {
			assertTrue(testFile.canRead());
		} else {
			assertFalse(testFile.canRead());
		}

		// tests directory, setReadable(false, true/false)
		assertTrue(testDir.canRead());
		assertTrue(testDir.setReadable(false, true));
		if (root) {
			assertTrue(testDir.canRead());
		} else {
			assertFalse(testDir.canRead());
		}
		assertTrue(testDir.setReadable(false, false));
		if (root) {
			assertTrue(testDir.canRead());
		} else {
			assertFalse(testDir.canRead());
		}

		// setReadable(true, false/true) and set them in turn
		assertTrue(testFile.setReadable(true, false));
		assertTrue(testFile.canRead());
		assertTrue(testFile.setReadable(false, true));
		if (root) {
			assertTrue(testFile.canRead());
		} else {
			assertFalse(testFile.canRead());
		}
		assertTrue(testFile.setReadable(true, true));
		assertTrue(testFile.canRead());
		assertTrue(testFile.setReadable(false, true));
		if (root) {
			assertTrue(testFile.canRead());
		} else {
			assertFalse(testFile.canRead());
		}

		// tests directory, setReadable(true, true/false)
		assertTrue(testDir.setReadable(true, false));
		assertTrue(testDir.canRead());
		assertTrue(testDir.setReadable(true, true));
		assertTrue(testDir.canRead());
	}

	/**
	 * @tests java.io.File#setReadable(boolean)
	 *
	 * @since 1.6
	 */
	public void test_setReadableZ() {
		// So far this method only deals with the situation that the user is the
		// owner of the file. setReadable(false) succeeds on Linux
		// However, canRead() always returns true when the user is 'root'.
		assertTrue(testFile.canRead());
		assertTrue(testFile.setReadable(false));
		if (root) {
			assertTrue(testFile.canRead());
		} else {
			assertFalse(testFile.canRead());
		}
		assertTrue(testFile.setReadable(true));
		assertTrue(testFile.canRead());

		assertTrue(testDir.canRead());
		assertTrue(testDir.setReadable(false));
		if (root) {
			assertTrue(testDir.canRead());
		} else {
			assertFalse(testDir.canRead());
		}
	}

	@Override
	protected void setUp() throws Exception {
		super.setUp();
		testFile = File.createTempFile("testfile", null);
		testDir = new File(System.getProperty("java.io.tmpdir") + "/temp");
		if (!testDir.exists()) {
			testDir.mkdir();
		}
		root = System.getProperty("user.name").equals("root");
	}

	@Override
	protected void tearDown() throws Exception {
		testFile.delete();
		testDir.delete();
		testFile = null;
		testDir = null;
		root = false;
		super.tearDown();
	}

    public void test_getCanonicalPath() throws IOException,
                                               InterruptedException {
        File tmpFolder1 = new File("folder1");
        tmpFolder1.mkdirs();
        tmpFolder1.deleteOnExit();

        File tmpFolder2 = new File(tmpFolder1.toString() + "/folder2");
        tmpFolder2.mkdirs();
        tmpFolder2.deleteOnExit();

        File tmpFolder3 = new File(tmpFolder2.toString() + "/folder3");
        tmpFolder3.mkdirs();
        tmpFolder3.deleteOnExit();

        File tmpFolder4 = new File(tmpFolder3.toString() + "/folder4");
        tmpFolder4.mkdirs();
        tmpFolder4.deleteOnExit();

        // make a link to folder1/folder2
        Process ln = Runtime.getRuntime().exec("ln -s folder1/folder2 folder2");
        ln.waitFor();
        File linkFile = new File("folder2");
        linkFile.deleteOnExit();

        File file = new File("folder2");
        assertEquals(tmpFolder2.getCanonicalPath(), file.getCanonicalPath());

        file = new File("folder1/folder2");
        assertEquals(tmpFolder2.getCanonicalPath(), file.getCanonicalPath());

        file = new File("folder2/folder3");
        assertEquals(tmpFolder3.getCanonicalPath(), file.getCanonicalPath());

        file = new File("folder2/folder3/folder4");
        assertEquals(tmpFolder4.getCanonicalPath(), file.getCanonicalPath());

        file = new File("folder1/folder2/folder3");
        assertEquals(tmpFolder3.getCanonicalPath(), file.getCanonicalPath());

        file = new File("folder1/folder2/folder3/folder4");
        assertEquals(tmpFolder4.getCanonicalPath(), file.getCanonicalPath());
    }
}