plugins/org.eclipse.epsilon.common/src/org/eclipse/epsilon/common/util/FileUtil.java - epsilon/org.eclipse.epsilon - Git at Google

 /*******************************************************************************
  * Copyright (c) 2008 The University of York.
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which is available at https://www.eclipse.org/legal/epl-2.0/
  *
  * Contributors:
  *     Dimitrios Kolovos - initial API and implementation
  ******************************************************************************/
 package org.eclipse.epsilon.common.util;

 import static java.nio.file.attribute.PosixFilePermission.OWNER_EXECUTE;
 import static java.nio.file.attribute.PosixFilePermission.OWNER_READ;
 import static java.nio.file.attribute.PosixFilePermission.OWNER_WRITE;
 import static java.security.AccessController.doPrivileged;

 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.UnsupportedEncodingException;
 import java.net.URISyntaxException;
 import java.net.URLDecoder;
 import java.nio.channels.FileChannel;
 import java.nio.file.DirectoryStream;
 import java.nio.file.FileAlreadyExistsException;
 import java.nio.file.FileSystems;
 import java.nio.file.Files;
 import java.nio.file.InvalidPathException;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.nio.file.attribute.FileAttribute;
 import java.nio.file.attribute.PosixFilePermission;
 import java.nio.file.attribute.PosixFilePermissions;
 import java.util.*;

 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 public class FileUtil {

 	private static Logger logger = LoggerFactory.getLogger(FileUtil.class);
 	// temporary directory location
 	private static final Path tmpdir = Paths.get(System.getProperty("java.io.tmpdir"));

 	private static final boolean isPosix = FileSystems.getDefault().supportedFileAttributeViews().contains("posix");

 	// default file and directory permissions (lazily initialized)
 	private static class PosixPermissions {
 		static final FileAttribute<Set<PosixFilePermission>> filePermissions = PosixFilePermissions
 				.asFileAttribute(EnumSet.of(OWNER_READ, OWNER_WRITE));
 		static final FileAttribute<Set<PosixFilePermission>> dirPermissions = PosixFilePermissions
 				.asFileAttribute(EnumSet.of(OWNER_READ, OWNER_WRITE, OWNER_EXECUTE));
 	}

 	private FileUtil() {
 	}

 	public static Path getCurrentDirectory() {
 		return Paths.get(".").toAbsolutePath().normalize();
 	}

 	public static void setFileContents(String str, File file) throws Exception {
 		try (FileWriter writer = new FileWriter(file)) {
 			writer.append(str);
 			writer.flush();
 		}
 	}

 	public static String replaceExtension(String filename, String newExtension) {
 		int dotIndex = filename.lastIndexOf('.');
 		if (dotIndex > -1) {
 			filename = filename.substring(0, dotIndex + 1) + newExtension;
 		}
 		return filename;
 	}

 	public static String removeExtension(String filename) {
 		int dotIndex = filename.lastIndexOf('.');
 		if (dotIndex > -1) {
 			filename = filename.substring(0, dotIndex);
 		}
 		return filename;
 	}

 	public static String getFileName(String path) {
 		return getFileName(path, true);
 	}

 	public static String getFileName(String path, boolean includeExtension) {
 		String filename = path.substring(path.replace("\\", "/").lastIndexOf('/') + 1);
 		if (!includeExtension) {
 			filename = removeExtension(filename);
 		}
 		return filename;
 	}

 	/**
 	 * Copied from @linkplain{https://stackoverflow.com/a/3571239/5870336}
 	 *
 	 * @param filename
 	 * @return
 	 * @since 1.6
 	 */
 	public static String getExtension(String filename) {
 		String extension = "";
 		int dotIndex = filename.lastIndexOf('.');
 		if (dotIndex > Math.max(filename.lastIndexOf('/'), filename.lastIndexOf('\\'))) {
 			extension = filename.substring(dotIndex + 1);
 		}
 		return extension;
 	}

 	public static String getFileContents(File file) throws Exception {
 		final StringBuffer buffer = new StringBuffer();
 		final String lineSeparator = System.getProperty("line.separator");

 		for (String line : getFileLineContents(file)) {
 			buffer.append(line);
 			buffer.append(lineSeparator);
 		}

 		return buffer.toString();
 	}

 	public static Collection<String> getFileLineContents(File file) throws Exception {
 		try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) {
 			final List<String> lines = new LinkedList<>();

 			String line = bufferedReader.readLine();

 			while (line != null) {
 				lines.add(line);
 				line = bufferedReader.readLine();
 			}

 			return lines;
 		}
 	}

 	public static String getAbsolutePath(String basePath, String relativePath) {
 		File file = new File(relativePath);
 		if (!file.isAbsolute()) {
 			file = new File(basePath, relativePath);
 		}
 		return file.getAbsolutePath();
 	}

 	/**
 	 * Gets a file stored as a resource in a jar. Since not all users of the file
 	 * can read from inside jars, we get the file as a stream and create a temp file
 	 * with its contents.
 	 *
 	 * @param name
 	 * @param relativeTo
 	 * @return
 	 */
 	public static File getFile(String name, Class<?> relativeTo) {
 		logger.info("getFile {}@{}", name, relativeTo.getSimpleName());
 		InputStream is = relativeTo.getResourceAsStream(name);
 		return inputStreamToFile(is, name);
 	}

 	@Deprecated
 	public static File getDirectoryOf(Class<?> clazz) {
 		return getFile(clazz.getSimpleName() + ".class", clazz).getParentFile();
 	}

 	@Deprecated
 	public static String getPath(String name, Class<?> relativeTo) {
 		return getFile(name, relativeTo).getAbsolutePath();
 	}

 	public static void checkFileExists(final File file) throws FileNotFoundException {
 		if (!file.exists()) {
 			throw new FileNotFoundException("File " + file.getPath() + " does not exist");
 		}
 	}

 	public static File createTempFile(String name) {
 		return createTempFile(name, "tmp");
 	}

 	public static File createTempFile(String name, String extension) {
 		Path tmpFile;
 		try {
 			// tmpFile = Files.createTempFile(name, extension);
 			tmpFile = createTempFile(null, name, extension);
 		} catch (IOException e) {
 			throw new IllegalArgumentException("Could not create temp file ", e);
 		}
 		return tmpFile.toFile();
 	}

 	public static File createTempDir(String name) {
 		return createTempDir(name, false);
 	}

 	public static File createTempDir(String name, boolean reuse) {
 		Path tmpFile = null;
 		if (reuse) {
 			DirectoryStream.Filter<Path> filter = new DirectoryStream.Filter<Path>() {
 				@Override
 				public boolean accept(Path file) throws IOException {
 					return (Files.isDirectory(file) && file.getFileName().startsWith(Paths.get(name)));
 				}
 			};
 			Iterator<Path> it;
 			try {
 				it = Files.newDirectoryStream(tmpdir, filter).iterator();
 				tmpFile = it.hasNext() ? it.next() : null;
 			} catch (IOException e) {
 				// TODO Auto-generated catch block
 				e.printStackTrace();
 			}
 		}
 		if (tmpFile == null) {
 			try {
 				tmpFile = createTempDirectory(null, name);
 			} catch (IOException e) {
 				throw new IllegalArgumentException("Could not create temp directory ", e);
 			}
 		}
 		return tmpFile.toFile();
 	}

 	public static File copyToTemp(File srcFile) throws IOException {
 		File tmpFile = File.createTempFile("filecompare", "tmp");
 		if (srcFile.isDirectory()) {
 			tmpFile.delete();
 			tmpFile.mkdir();
 		}
 		copy(srcFile, tmpFile);
 		return tmpFile;
 	}

 	public static void copy(File srcFile, File dstFile) throws IOException {
 		if (srcFile.isDirectory()) {
 			dstFile.mkdir();
 			for (File entry : srcFile.listFiles()) {
 				copy(entry, new File(dstFile, entry.getName()));
 			}
 		} else {
 			// Based on the second answer in http://stackoverflow.com/questions/106770.
 			FileInputStream isSrc = null;
 			FileOutputStream osDst = null;
 			FileChannel chSrc = null;
 			FileChannel chDst = null;
 			try {
 				isSrc = new FileInputStream(srcFile);
 				osDst = new FileOutputStream(dstFile);
 				chSrc = isSrc.getChannel();
 				chDst = osDst.getChannel();
 				final long srcBytes = srcFile.length();
 				long transferred = 0;
 				while (transferred < srcBytes) {
 					transferred += chDst.transferFrom(chSrc, transferred, srcBytes);
 					chDst.position(transferred);
 				}
 			} finally {
 				if (chDst != null) {
 					chDst.close();
 				} else if (osDst != null) {
 					osDst.close();
 				}

 				if (chSrc != null) {
 					chSrc.close();
 				} else if (isSrc != null) {
 					isSrc.close();
 				}
 			}
 		}
 	}

 	public static Set<String> listFilesAsSet(File fileExpected) {
 		return new HashSet<>(Arrays.asList(fileExpected.list()));
 	}

 	/**
 	 * We implement our own comparison algorithm here, so we don't need Eclipse
 	 * Compare to compute differences, but rather only to show them in the UI.
 	 */
 	public static boolean sameContents(File fileExpected, File fileActual, Set<String> ignoreFilenames)
 			throws IOException {
 		if (fileExpected.isDirectory() != fileActual.isDirectory()) {
 			// One is a file, the other is a directory: not the same
 			return false;
 		}

 		if (fileExpected.isDirectory()) {
 			// Both are directories: they should contain the same filenames,
 			// and each pair should have the same contents
 			final Set<String> expectedFilenames = listFilesAsSet(fileExpected);
 			final Set<String> actualFilenames = listFilesAsSet(fileActual);
 			expectedFilenames.removeAll(ignoreFilenames);
 			actualFilenames.removeAll(ignoreFilenames);

 			if (!expectedFilenames.equals(actualFilenames)) {
 				return false;
 			}
 			for (String filename : expectedFilenames) {
 				final File expectedEntry = new File(fileExpected, filename);
 				final File actualEntry = new File(fileActual, filename);
 				if (!sameContents(expectedEntry, actualEntry, ignoreFilenames)) {
 					return false;
 				}
 			}
 			return true;
 		} else {
 			if (fileExpected.length() != fileActual.length()) {
 				// Different length: no need to read the files
 				return false;
 			}

 			try (FileInputStream isExpected = new FileInputStream(fileExpected)) {
 				try (FileInputStream isActual = new FileInputStream(fileActual)) {
 					return sameContents(isExpected, isActual);
 				}
 			}
 		}
 	}

 	public static boolean sameContents(InputStream isExpected, InputStream isActual) throws IOException {
 		int chExpected, chActual;

 		do {
 			chExpected = isExpected.read();
 			chActual = isActual.read();
 		} while (chExpected == chActual && chExpected > 0 && chActual > 0);

 		return chExpected == chActual;
 	}

 	/**
 	 * WARNIING: Use with caution! Deletes all contents and sub-directories of the
 	 * specified path.
 	 *
 	 * @param dir The absolute path to the directory.
 	 * @throws IOException
 	 * @since 1.6
 	 */
 	public static void deleteDirectory(String dir) throws IOException {
 		Path path = Paths.get(dir);
 		if (Files.exists(path)) {
 			Files.walk(path).map(Path::toFile).sorted((o1, o2) -> -o1.compareTo(o2)).forEach(File::delete);
 		}
 	}

 	/**
 	 * Reads entire directory recursively, mapping the contents of each file as a
 	 * string to its path.
 	 *
 	 * @param dir The root directory.
 	 * @return The contents of each file in the directory and its subdirectories.
 	 * @throws IOException
 	 * @since 1.6
 	 */
 	public static Map<Path, String> readDirectory(String dir) throws IOException {
 		Map<Path, String> contents = new HashMap<>();

 		for (Path path : ((Iterable<Path>) Files.walk(Paths.get(dir))::iterator)) {
 			if (Files.isRegularFile(path)) {
 				contents.put(path, new String(Files.readAllBytes(path)));
 			}
 		}

 		return contents;
 	}

 	private static File inputStreamToFile(InputStream inputStream, String name) {
 		logger.debug("inputStreamToFile {}", name);
 		OutputStream outputStream = null;
 		String prefix = name;
 		String suffix = "";
 		Path dirStructure = null;

 		// Name might be a path, get the file name, remove it
 		if (name.contains("/")) {
 			dirStructure = Paths.get(tmpdir.toString(), name.substring(0, name.lastIndexOf("/")), "/");
 			dirStructure.toFile().mkdirs();
 			name = name.substring(name.lastIndexOf("/") + 1);
 			logger.debug("inputStreamToFile {}", name);
 		}

 		String[] parts = name.split("\\.");
 		if (parts.length == 2) {
 			prefix = parts[0];
 			suffix = "." + parts[1];
 			logger.debug("splitting name and extension: {} - {}", prefix, suffix);
 		}
 		File file = null;
 		try {
 			Path tempFile;
 			try {
 				// tempFile = Files.createTempFile(prefix, sufix);
 				tempFile = createTempFile(dirStructure, prefix, suffix);
 			} catch (IllegalArgumentException e) {
 				logger.error("Error creating temp file: {}-{}", prefix, suffix, e);
 				throw e;
 			}
 			outputStream = new FileOutputStream(tempFile.toFile());

 			int read = 0;
 			byte[] bytes = new byte[1024];
 			logger.debug("{} bytes available", inputStream.available());
 			while ((read = inputStream.read(bytes)) != -1) {
 				logger.debug("{} bytes read from input", read);
 				outputStream.write(bytes, 0, read);
 			}
 			logger.debug("Copying data into temp file Done!");
 //			Runtime.getRuntime().addShutdownHook(new Thread() {
 //	            @Override
 //	            public void run() {
 //	                try {
 //	                    Files.delete(tempFile);
 //	                } catch (IOException e) {
 //	                    e.printStackTrace();
 //	                }
 //	            }
 //	        });
 			file = tempFile.toFile();

 		} catch (IOException e) {
 			logger.error("Unable to create File for resoruce", e);
 			e.printStackTrace();
 		} finally {
 			if (inputStream != null) {
 				try {
 					inputStream.close();
 				} catch (IOException e) {
 					e.printStackTrace();
 				}
 			}
 			if (outputStream != null) {
 				try {
 					outputStream.close();
 				} catch (IOException e) {
 					e.printStackTrace();
 				}

 			}
 		}

 		return file;
 	}

 	static Path createTempDirectory(Path dir, String prefix, FileAttribute<?>... attrs) throws IOException {
 		return create(dir, prefix, null, true, attrs);
 	}

 	static Path createTempFile(Path dir, String prefix, String suffix, FileAttribute<?>... attrs) throws IOException {
 		return create(dir, prefix, suffix, false, attrs);
 	}

 	/**
 	 * Creates a file or directory in in the given given directory (or in the
 	 * temporary directory if dir is {@code null}).
 	 */
 	private static Path create(Path dir, String prefix, String suffix, boolean createDirectory,
 			FileAttribute<?>[] attrs) throws IOException {
 		if (prefix == null)
 			prefix = "";
 		if (suffix == null)
 			suffix = (createDirectory) ? "" : ".tmp";
 		if (dir == null)
 			dir = tmpdir;

 		// in POSIX environments use default file and directory permissions
 		// if initial permissions not given by caller.
 		if (isPosix && (dir.getFileSystem() == FileSystems.getDefault())) {
 			if (attrs.length == 0) {
 				// no attributes so use default permissions
 				attrs = new FileAttribute<?>[1];
 				attrs[0] = (createDirectory) ? PosixPermissions.dirPermissions : PosixPermissions.filePermissions;
 			} else {
 				// check if posix permissions given; if not use default
 				boolean hasPermissions = false;
 				for (int i = 0; i < attrs.length; i++) {
 					if (attrs[i].name().equals("posix:permissions")) {
 						hasPermissions = true;
 						break;
 					}
 				}
 				if (!hasPermissions) {
 					FileAttribute<?>[] copy = new FileAttribute<?>[attrs.length + 1];
 					System.arraycopy(attrs, 0, copy, 0, attrs.length);
 					attrs = copy;
 					attrs[attrs.length - 1] = (createDirectory) ? PosixPermissions.dirPermissions
 							: PosixPermissions.filePermissions;
 				}
 			}
 		}

 		// loop generating random names until file or directory can be created
 		SecurityManager sm = System.getSecurityManager();
 		//for (;;) {
 			Path f;
 			try {
 				f = generatePath(prefix, suffix, dir);
 			} catch (InvalidPathException e) {
 				// don't reveal temporary directory location
 				if (sm != null)
 					throw new IllegalArgumentException("Invalid prefix or suffix");
 				throw e;
 			}
 			try {
 				if (createDirectory) {
 					return Files.createDirectory(f, attrs);
 				} else {
 					return Files.createFile(f, attrs);
 				}
 			} catch (SecurityException e) {
 				// don't reveal temporary directory location
 				if (dir == tmpdir && sm != null)
 					throw new SecurityException("Unable to create temporary file or directory");
 				throw e;
 			} catch (FileAlreadyExistsException e) {
 				// FIXME Add the file deletion so we dont need this.
 				// FIXME or make each test use a different folder...
 				logger.debug("File found, reusing");
 				return f;

 			}
 		//}
 	}

 	private static Path generatePath(String prefix, String suffix, Path dir) {
 		Path name = dir.getFileSystem().getPath(prefix + suffix);
 		// the generated name should be a simple file name
 		if (name.getParent() != null)
 			throw new IllegalArgumentException("Invalid prefix or suffix");
 		return dir.resolve(name);
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2008 The University of York.
	* This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License 2.0
	* which is available at https://www.eclipse.org/legal/epl-2.0/
	*
	* Contributors:
	* Dimitrios Kolovos - initial API and implementation
	******************************************************************************/
	package org.eclipse.epsilon.common.util;

	import static java.nio.file.attribute.PosixFilePermission.OWNER_EXECUTE;
	import static java.nio.file.attribute.PosixFilePermission.OWNER_READ;
	import static java.nio.file.attribute.PosixFilePermission.OWNER_WRITE;
	import static java.security.AccessController.doPrivileged;

	import java.io.BufferedReader;
	import java.io.File;
	import java.io.FileInputStream;
	import java.io.FileNotFoundException;
	import java.io.FileOutputStream;
	import java.io.FileReader;
	import java.io.FileWriter;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.io.UnsupportedEncodingException;
	import java.net.URISyntaxException;
	import java.net.URLDecoder;
	import java.nio.channels.FileChannel;
	import java.nio.file.DirectoryStream;
	import java.nio.file.FileAlreadyExistsException;
	import java.nio.file.FileSystems;
	import java.nio.file.Files;
	import java.nio.file.InvalidPathException;
	import java.nio.file.Path;
	import java.nio.file.Paths;
	import java.nio.file.attribute.FileAttribute;
	import java.nio.file.attribute.PosixFilePermission;
	import java.nio.file.attribute.PosixFilePermissions;
	import java.util.*;

	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	public class FileUtil {

	private static Logger logger = LoggerFactory.getLogger(FileUtil.class);
	// temporary directory location
	private static final Path tmpdir = Paths.get(System.getProperty("java.io.tmpdir"));

	private static final boolean isPosix = FileSystems.getDefault().supportedFileAttributeViews().contains("posix");

	// default file and directory permissions (lazily initialized)
	private static class PosixPermissions {
	static final FileAttribute<Set<PosixFilePermission>> filePermissions = PosixFilePermissions
	.asFileAttribute(EnumSet.of(OWNER_READ, OWNER_WRITE));
	static final FileAttribute<Set<PosixFilePermission>> dirPermissions = PosixFilePermissions
	.asFileAttribute(EnumSet.of(OWNER_READ, OWNER_WRITE, OWNER_EXECUTE));
	}

	private FileUtil() {
	}

	public static Path getCurrentDirectory() {
	return Paths.get(".").toAbsolutePath().normalize();
	}

	public static void setFileContents(String str, File file) throws Exception {
	try (FileWriter writer = new FileWriter(file)) {
	writer.append(str);
	writer.flush();
	}
	}

	public static String replaceExtension(String filename, String newExtension) {
	int dotIndex = filename.lastIndexOf('.');
	if (dotIndex > -1) {
	filename = filename.substring(0, dotIndex + 1) + newExtension;
	}
	return filename;
	}

	public static String removeExtension(String filename) {
	int dotIndex = filename.lastIndexOf('.');
	if (dotIndex > -1) {
	filename = filename.substring(0, dotIndex);
	}
	return filename;
	}

	public static String getFileName(String path) {
	return getFileName(path, true);
	}

	public static String getFileName(String path, boolean includeExtension) {
	String filename = path.substring(path.replace("\\", "/").lastIndexOf('/') + 1);
	if (!includeExtension) {
	filename = removeExtension(filename);
	}
	return filename;
	}

	/**
	* Copied from @linkplain{https://stackoverflow.com/a/3571239/5870336}
	*
	* @param filename
	* @return
	* @since 1.6
	*/
	public static String getExtension(String filename) {
	String extension = "";
	int dotIndex = filename.lastIndexOf('.');
	if (dotIndex > Math.max(filename.lastIndexOf('/'), filename.lastIndexOf('\\'))) {
	extension = filename.substring(dotIndex + 1);
	}
	return extension;
	}

	public static String getFileContents(File file) throws Exception {
	final StringBuffer buffer = new StringBuffer();
	final String lineSeparator = System.getProperty("line.separator");

	for (String line : getFileLineContents(file)) {
	buffer.append(line);
	buffer.append(lineSeparator);
	}

	return buffer.toString();
	}

	public static Collection<String> getFileLineContents(File file) throws Exception {
	try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) {
	final List<String> lines = new LinkedList<>();

	String line = bufferedReader.readLine();

	while (line != null) {
	lines.add(line);
	line = bufferedReader.readLine();
	}

	return lines;
	}
	}

	public static String getAbsolutePath(String basePath, String relativePath) {
	File file = new File(relativePath);
	if (!file.isAbsolute()) {
	file = new File(basePath, relativePath);
	}
	return file.getAbsolutePath();
	}

	/**
	* Gets a file stored as a resource in a jar. Since not all users of the file
	* can read from inside jars, we get the file as a stream and create a temp file
	* with its contents.
	*
	* @param name
	* @param relativeTo
	* @return
	*/
	public static File getFile(String name, Class<?> relativeTo) {
	logger.info("getFile {}@{}", name, relativeTo.getSimpleName());
	InputStream is = relativeTo.getResourceAsStream(name);
	return inputStreamToFile(is, name);
	}

	@Deprecated
	public static File getDirectoryOf(Class<?> clazz) {
	return getFile(clazz.getSimpleName() + ".class", clazz).getParentFile();
	}

	@Deprecated
	public static String getPath(String name, Class<?> relativeTo) {
	return getFile(name, relativeTo).getAbsolutePath();
	}

	public static void checkFileExists(final File file) throws FileNotFoundException {
	if (!file.exists()) {
	throw new FileNotFoundException("File " + file.getPath() + " does not exist");
	}
	}

	public static File createTempFile(String name) {
	return createTempFile(name, "tmp");
	}

	public static File createTempFile(String name, String extension) {
	Path tmpFile;
	try {
	// tmpFile = Files.createTempFile(name, extension);
	tmpFile = createTempFile(null, name, extension);
	} catch (IOException e) {
	throw new IllegalArgumentException("Could not create temp file ", e);
	}
	return tmpFile.toFile();
	}

	public static File createTempDir(String name) {
	return createTempDir(name, false);
	}

	public static File createTempDir(String name, boolean reuse) {
	Path tmpFile = null;
	if (reuse) {
	DirectoryStream.Filter<Path> filter = new DirectoryStream.Filter<Path>() {
	@Override
	public boolean accept(Path file) throws IOException {
	return (Files.isDirectory(file) && file.getFileName().startsWith(Paths.get(name)));
	}
	};
	Iterator<Path> it;
	try {
	it = Files.newDirectoryStream(tmpdir, filter).iterator();
	tmpFile = it.hasNext() ? it.next() : null;
	} catch (IOException e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
	}
	}
	if (tmpFile == null) {
	try {
	tmpFile = createTempDirectory(null, name);
	} catch (IOException e) {
	throw new IllegalArgumentException("Could not create temp directory ", e);
	}
	}
	return tmpFile.toFile();
	}

	public static File copyToTemp(File srcFile) throws IOException {
	File tmpFile = File.createTempFile("filecompare", "tmp");
	if (srcFile.isDirectory()) {
	tmpFile.delete();
	tmpFile.mkdir();
	}
	copy(srcFile, tmpFile);
	return tmpFile;
	}

	public static void copy(File srcFile, File dstFile) throws IOException {
	if (srcFile.isDirectory()) {
	dstFile.mkdir();
	for (File entry : srcFile.listFiles()) {
	copy(entry, new File(dstFile, entry.getName()));
	}
	} else {
	// Based on the second answer in http://stackoverflow.com/questions/106770.
	FileInputStream isSrc = null;
	FileOutputStream osDst = null;
	FileChannel chSrc = null;
	FileChannel chDst = null;
	try {
	isSrc = new FileInputStream(srcFile);
	osDst = new FileOutputStream(dstFile);
	chSrc = isSrc.getChannel();
	chDst = osDst.getChannel();
	final long srcBytes = srcFile.length();
	long transferred = 0;
	while (transferred < srcBytes) {
	transferred += chDst.transferFrom(chSrc, transferred, srcBytes);
	chDst.position(transferred);
	}
	} finally {
	if (chDst != null) {
	chDst.close();
	} else if (osDst != null) {
	osDst.close();
	}

	if (chSrc != null) {
	chSrc.close();
	} else if (isSrc != null) {
	isSrc.close();
	}
	}
	}
	}

	public static Set<String> listFilesAsSet(File fileExpected) {
	return new HashSet<>(Arrays.asList(fileExpected.list()));
	}

	/**
	* We implement our own comparison algorithm here, so we don't need Eclipse
	* Compare to compute differences, but rather only to show them in the UI.
	*/
	public static boolean sameContents(File fileExpected, File fileActual, Set<String> ignoreFilenames)
	throws IOException {
	if (fileExpected.isDirectory() != fileActual.isDirectory()) {
	// One is a file, the other is a directory: not the same
	return false;
	}

	if (fileExpected.isDirectory()) {
	// Both are directories: they should contain the same filenames,
	// and each pair should have the same contents
	final Set<String> expectedFilenames = listFilesAsSet(fileExpected);
	final Set<String> actualFilenames = listFilesAsSet(fileActual);
	expectedFilenames.removeAll(ignoreFilenames);
	actualFilenames.removeAll(ignoreFilenames);

	if (!expectedFilenames.equals(actualFilenames)) {
	return false;
	}
	for (String filename : expectedFilenames) {
	final File expectedEntry = new File(fileExpected, filename);
	final File actualEntry = new File(fileActual, filename);
	if (!sameContents(expectedEntry, actualEntry, ignoreFilenames)) {
	return false;
	}
	}
	return true;
	} else {
	if (fileExpected.length() != fileActual.length()) {
	// Different length: no need to read the files
	return false;
	}

	try (FileInputStream isExpected = new FileInputStream(fileExpected)) {
	try (FileInputStream isActual = new FileInputStream(fileActual)) {
	return sameContents(isExpected, isActual);
	}
	}
	}
	}

	public static boolean sameContents(InputStream isExpected, InputStream isActual) throws IOException {
	int chExpected, chActual;

	do {
	chExpected = isExpected.read();
	chActual = isActual.read();
	} while (chExpected == chActual && chExpected > 0 && chActual > 0);

	return chExpected == chActual;
	}

	/**
	* WARNIING: Use with caution! Deletes all contents and sub-directories of the
	* specified path.
	*
	* @param dir The absolute path to the directory.
	* @throws IOException
	* @since 1.6
	*/
	public static void deleteDirectory(String dir) throws IOException {
	Path path = Paths.get(dir);
	if (Files.exists(path)) {
	Files.walk(path).map(Path::toFile).sorted((o1, o2) -> -o1.compareTo(o2)).forEach(File::delete);
	}
	}

	/**
	* Reads entire directory recursively, mapping the contents of each file as a
	* string to its path.
	*
	* @param dir The root directory.
	* @return The contents of each file in the directory and its subdirectories.
	* @throws IOException
	* @since 1.6
	*/
	public static Map<Path, String> readDirectory(String dir) throws IOException {
	Map<Path, String> contents = new HashMap<>();

	for (Path path : ((Iterable<Path>) Files.walk(Paths.get(dir))::iterator)) {
	if (Files.isRegularFile(path)) {
	contents.put(path, new String(Files.readAllBytes(path)));
	}
	}

	return contents;
	}

	private static File inputStreamToFile(InputStream inputStream, String name) {
	logger.debug("inputStreamToFile {}", name);
	OutputStream outputStream = null;
	String prefix = name;
	String suffix = "";
	Path dirStructure = null;

	// Name might be a path, get the file name, remove it
	if (name.contains("/")) {
	dirStructure = Paths.get(tmpdir.toString(), name.substring(0, name.lastIndexOf("/")), "/");
	dirStructure.toFile().mkdirs();
	name = name.substring(name.lastIndexOf("/") + 1);
	logger.debug("inputStreamToFile {}", name);
	}

	String[] parts = name.split("\\.");
	if (parts.length == 2) {
	prefix = parts[0];
	suffix = "." + parts[1];
	logger.debug("splitting name and extension: {} - {}", prefix, suffix);
	}
	File file = null;
	try {
	Path tempFile;
	try {
	// tempFile = Files.createTempFile(prefix, sufix);
	tempFile = createTempFile(dirStructure, prefix, suffix);
	} catch (IllegalArgumentException e) {
	logger.error("Error creating temp file: {}-{}", prefix, suffix, e);
	throw e;
	}
	outputStream = new FileOutputStream(tempFile.toFile());

	int read = 0;
	byte[] bytes = new byte[1024];
	logger.debug("{} bytes available", inputStream.available());
	while ((read = inputStream.read(bytes)) != -1) {
	logger.debug("{} bytes read from input", read);
	outputStream.write(bytes, 0, read);
	}
	logger.debug("Copying data into temp file Done!");
	// Runtime.getRuntime().addShutdownHook(new Thread() {
	// @Override
	// public void run() {
	// try {
	// Files.delete(tempFile);
	// } catch (IOException e) {
	// e.printStackTrace();
	// }
	// }
	// });
	file = tempFile.toFile();

	} catch (IOException e) {
	logger.error("Unable to create File for resoruce", e);
	e.printStackTrace();
	} finally {
	if (inputStream != null) {
	try {
	inputStream.close();
	} catch (IOException e) {
	e.printStackTrace();
	}
	}
	if (outputStream != null) {
	try {
	outputStream.close();
	} catch (IOException e) {
	e.printStackTrace();
	}

	}
	}

	return file;
	}

	static Path createTempDirectory(Path dir, String prefix, FileAttribute<?>... attrs) throws IOException {
	return create(dir, prefix, null, true, attrs);
	}

	static Path createTempFile(Path dir, String prefix, String suffix, FileAttribute<?>... attrs) throws IOException {
	return create(dir, prefix, suffix, false, attrs);
	}

	/**
	* Creates a file or directory in in the given given directory (or in the
	* temporary directory if dir is {@code null}).
	*/
	private static Path create(Path dir, String prefix, String suffix, boolean createDirectory,
	FileAttribute<?>[] attrs) throws IOException {
	if (prefix == null)
	prefix = "";
	if (suffix == null)
	suffix = (createDirectory) ? "" : ".tmp";
	if (dir == null)
	dir = tmpdir;

	// in POSIX environments use default file and directory permissions
	// if initial permissions not given by caller.
	if (isPosix && (dir.getFileSystem() == FileSystems.getDefault())) {
	if (attrs.length == 0) {
	// no attributes so use default permissions
	attrs = new FileAttribute<?>[1];
	attrs[0] = (createDirectory) ? PosixPermissions.dirPermissions : PosixPermissions.filePermissions;
	} else {
	// check if posix permissions given; if not use default
	boolean hasPermissions = false;
	for (int i = 0; i < attrs.length; i++) {
	if (attrs[i].name().equals("posix:permissions")) {
	hasPermissions = true;
	break;
	}
	}
	if (!hasPermissions) {
	FileAttribute<?>[] copy = new FileAttribute<?>[attrs.length + 1];
	System.arraycopy(attrs, 0, copy, 0, attrs.length);
	attrs = copy;
	attrs[attrs.length - 1] = (createDirectory) ? PosixPermissions.dirPermissions
	: PosixPermissions.filePermissions;
	}
	}
	}

	// loop generating random names until file or directory can be created
	SecurityManager sm = System.getSecurityManager();
	//for (;;) {
	Path f;
	try {
	f = generatePath(prefix, suffix, dir);
	} catch (InvalidPathException e) {
	// don't reveal temporary directory location
	if (sm != null)
	throw new IllegalArgumentException("Invalid prefix or suffix");
	throw e;
	}
	try {
	if (createDirectory) {
	return Files.createDirectory(f, attrs);
	} else {
	return Files.createFile(f, attrs);
	}
	} catch (SecurityException e) {
	// don't reveal temporary directory location
	if (dir == tmpdir && sm != null)
	throw new SecurityException("Unable to create temporary file or directory");
	throw e;
	} catch (FileAlreadyExistsException e) {
	// FIXME Add the file deletion so we dont need this.
	// FIXME or make each test use a different folder...
	logger.debug("File found, reusing");
	return f;

	}
	//}
	}

	private static Path generatePath(String prefix, String suffix, Path dir) {
	Path name = dir.getFileSystem().getPath(prefix + suffix);
	// the generated name should be a simple file name
	if (name.getParent() != null)
	throw new IllegalArgumentException("Invalid prefix or suffix");
	return dir.resolve(name);
	}
	}