org.eclipse.jdt.debug.tests/test plugin/org/eclipse/jdt/debug/testplugin/JavaProjectHelper.java - jdt/eclipse.jdt.debug - Git at Google

 /*******************************************************************************
  *  Copyright (c) 2000, 2015 IBM Corporation and others.
  *  All rights reserved. This program and the accompanying materials
  *  are made available under the terms of the Eclipse Public License v1.0
  *  which accompanies this distribution, and is available at
  *  http://www.eclipse.org/legal/epl-v10.html
  *
  * This is an implementation of an early-draft specification developed under the Java
  * Community Process (JCP) and is made available for testing and evaluation purposes
  * only. The code is not compatible with any specification of the JCP.
  *
  *  Contributors:
  *     IBM Corporation - initial API and implementation
  *     Jesper S. Møller - bug 422029: [1.8] Enable debug evaluation support for default methods
  *******************************************************************************/
 package org.eclipse.jdt.debug.testplugin;

 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.zip.ZipFile;

 import org.eclipse.core.resources.IContainer;
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IFolder;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IProjectDescription;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.resources.IWorkspaceRoot;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.jdt.core.IClasspathEntry;
 import org.eclipse.jdt.core.IJavaProject;
 import org.eclipse.jdt.core.IPackageFragmentRoot;
 import org.eclipse.jdt.core.JavaCore;
 import org.eclipse.jdt.core.JavaModelException;
 import org.eclipse.jdt.internal.core.ClasspathEntry;
 import org.eclipse.ui.dialogs.IOverwriteQuery;
 import org.eclipse.ui.wizards.datatransfer.FileSystemStructureProvider;
 import org.eclipse.ui.wizards.datatransfer.IImportStructureProvider;
 import org.eclipse.ui.wizards.datatransfer.ImportOperation;
 import org.eclipse.ui.wizards.datatransfer.ZipFileStructureProvider;

 /**
  * Helper methods to set up a IJavaProject.
  */
 public class JavaProjectHelper {

 	public static final String SRC_DIR = "src";
 	public static final String BIN_DIR = "bin";
 	public static final String J2SE_1_4_EE_NAME = "J2SE-1.4";
 	public static final String J2SE_1_5_EE_NAME = "J2SE-1.5";
 	public static final String JAVA_SE_1_6_EE_NAME = "JavaSE-1.6";
 	public static final String JAVA_SE_1_7_EE_NAME = "JavaSE-1.7";
 	public static final String JAVA_SE_1_8_EE_NAME = "JavaSE-1.8";

 	/**
 	 * path to the test src for 'testprograms'
 	 */
 	public static final IPath TEST_SRC_DIR= new Path("testprograms");

 	/**
 	 * path to the 1.5 test source
 	 */
 	public static final IPath TEST_1_5_SRC_DIR= new Path("testsource-j2se-1.5");
 	/**
 	 * path to the 1.7 test source
 	 */
 	public static final IPath TEST_1_7_SRC_DIR= new Path("java7");
 	/**
 	 * path to the 1.8 test source
 	 */
 	public static final IPath TEST_1_8_SRC_DIR= new Path("java8");

 	/**
 	 * path to the compiler error java file
 	 */
 	public static final IPath TEST_COMPILE_ERROR = new Path("testresources/CompilationError.java");

 	public static final String JRE_CONTAINER_NAME = "org.eclipse.jdt.launching.JRE_CONTAINER";


 	/**
 	 * Returns if the currently running VM is version compatible with Java 8
 	 *
 	 * @return <code>true</code> if a Java 8 (or greater) VM is running <code>false</code> otherwise
 	 */
 	public static boolean isJava8Compatible() {
 		return isCompatible(8);
 	}
 	/**
 	 * Returns if the currently running VM is version compatible with Java 7
 	 *
 	 * @return <code>true</code> if a Java 7 (or greater) VM is running <code>false</code> otherwise
 	 */
 	public static boolean isJava7Compatible() {
 		return isCompatible(7);
 	}

 	/**
 	 * Returns if the currently running VM is version compatible with Java 6
 	 *
 	 * @return <code>true</code> if a Java 6 (or greater) VM is running <code>false</code> otherwise
 	 */
 	public static boolean isJava6Compatible() {
 		return isCompatible(6);
 	}

 	/**
 	 * Returns if the currently running VM is version compatible with Java 5
 	 *
 	 * @return <code>true</code> if a Java 5 (or greater) VM is running <code>false</code> otherwise
 	 */
 	public static boolean isJava5Compatible() {
 		return isCompatible(5);
 	}

 	/**
 	 * Returns if the current running system is compatible with the given Java minor version
 	 *
 	 * @param ver the version to test - either 4, 5, 6, 7 or 8
 	 * @return <code>true</code> if compatible <code>false</code> otherwise
 	 */
 	static boolean isCompatible(int ver) {
 		String version = System.getProperty("java.specification.version");
 		if (version != null) {
 			String[] nums = version.split("\\.");
 			if (nums.length == 2) {
 				try {
 					int major = Integer.parseInt(nums[0]);
 					int minor = Integer.parseInt(nums[1]);
 					if (major >= 1) {
 						if (minor >= ver) {
 							return true;
 						}
 					}
 				} catch (NumberFormatException e) {
 				}
 			}
 		}
 		return false;
 	}

 	/**
 	 * Creates a new {@link IProject} with the given name unless the project already exists. If it already exists
 	 * the project is refreshed and opened (if closed)
 	 *
 	 * @param pname the desired name for the project
 	 * @return the new {@link IProject} handle
 	 * @throws CoreException
 	 */
 	public static IProject createProject(String pname) throws CoreException {
 		IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
 		IProject project = root.getProject(pname);
 		if (!project.exists()) {
 			project.create(null);
 		} else {
 			project.refreshLocal(IResource.DEPTH_INFINITE, null);
 		}
 		if (!project.isOpen()) {
 			project.open(null);
 		}
 		return project;
 	}

 	/**
 	 * creates a java project with the specified name and output folder
 	 * @param projectName
 	 * @param binFolderName
 	 * @return a new java project
 	 * @throws CoreException
 	 */
 	public static IJavaProject createJavaProject(String projectName, String binFolderName) throws CoreException {
 		IProject project = createProject(projectName);
 		IPath outputLocation;
 		if (binFolderName != null && binFolderName.length() > 0) {
 			IFolder binFolder= project.getFolder(binFolderName);
 			if (!binFolder.exists()) {
 				binFolder.create(false, true, null);
 			}
 			outputLocation= binFolder.getFullPath();
 		} else {
 			outputLocation= project.getFullPath();
 		}
 		if (!project.hasNature(JavaCore.NATURE_ID)) {
 			addNatureToProject(project, JavaCore.NATURE_ID, null);
 		}
 		IJavaProject jproject= JavaCore.create(project);
 		jproject.setOutputLocation(outputLocation, null);
 		jproject.setRawClasspath(new IClasspathEntry[0], null);
 		return jproject;
 	}

 	/**
 	 * Creates a new Java project with the specified name
 	 * @param projectName
 	 * @return a new java project with the specified name
 	 * @throws CoreException
 	 */
 	public static IJavaProject createJavaProject(String projectName) throws CoreException {
 		IProject project = createProject(projectName);
 		if (!project.hasNature(JavaCore.NATURE_ID)) {
 			addNatureToProject(project, JavaCore.NATURE_ID, null);
 		}
 		IJavaProject jproject= JavaCore.create(project);
 		jproject.setRawClasspath(new IClasspathEntry[0], null);
 		return jproject;
 	}

 	/**
 	 * deletes a java project
 	 * @param jproject
 	 * @throws CoreException
 	 */
 	public static void delete(IJavaProject jproject) throws CoreException {
 		jproject.setRawClasspath(new ClasspathEntry[0], jproject.getProject().getFullPath(), null);
 		jproject.getProject().delete(true, true, null);
 	}

 	/**
 	 * Adds a new source container specified by the container name to the source path of the specified project
 	 * @param jproject
 	 * @param containerName
 	 * @return the package fragment root of the container name
 	 * @throws CoreException
 	 */
 	public static IPackageFragmentRoot addSourceContainer(IJavaProject jproject, String containerName) throws CoreException {
 		IProject project= jproject.getProject();
 		IContainer container= null;
 		if (containerName == null || containerName.length() == 0) {
 			container= project;
 		} else {
 			IFolder folder= project.getFolder(containerName);
 			if (!folder.exists()) {
 				folder.create(false, true, null);
 			}
 			container= folder;
 		}
 		IPackageFragmentRoot root= jproject.getPackageFragmentRoot(container);

 		IClasspathEntry cpe= JavaCore.newSourceEntry(root.getPath());
 		addToClasspath(jproject, cpe);
 		return root;
 	}

 	/**
 	 * Adds a source container to a IJavaProject.
 	 * @param jproject
 	 * @param containerName
 	 * @param outputName
 	 * @return the package fragment root of the new source container
 	 * @throws CoreException
 	 */
 	public static IPackageFragmentRoot addSourceContainer(IJavaProject jproject, String containerName, String outputName) throws CoreException {
 		IProject project= jproject.getProject();
 		IContainer container= null;
 		if (containerName == null || containerName.length() == 0) {
 			container= project;
 		} else {
 			IFolder folder= project.getFolder(containerName);
 			if (!folder.exists()) {
 				folder.create(false, true, null);
 			}
 			container= folder;
 		}
 		IPackageFragmentRoot root= jproject.getPackageFragmentRoot(container);

 		IFolder output = null;
 		if (outputName!= null) {
 			output = project.getFolder(outputName);
 			if (!output.exists()) {
 				output.create(false, true, null);
 			}
 		}

 		IClasspathEntry cpe= JavaCore.newSourceEntry(root.getPath(), new IPath[0], output.getFullPath());

 		addToClasspath(jproject, cpe);
 		return root;
 	}

 	/**
 	 * Adds a source container to a IJavaProject and imports all files contained
 	 * in the given Zip file.
 	 * @param jproject
 	 * @param containerName
 	 * @param zipFile
 	 * @return the package fragment root of the new source container
 	 * @throws InvocationTargetException
 	 * @throws CoreException
 	 */
 	public static IPackageFragmentRoot addSourceContainerWithImport(IJavaProject jproject, String containerName, ZipFile zipFile) throws InvocationTargetException, CoreException {
 		IPackageFragmentRoot root= addSourceContainer(jproject, containerName);
 		importFilesFromZip(zipFile, root.getPath(), null);
 		return root;
 	}

 	/**
 	 * Removes a source folder from a IJavaProject.
 	 * @param jproject
 	 * @param containerName
 	 * @throws CoreException
 	 */
 	public static void removeSourceContainer(IJavaProject jproject, String containerName) throws CoreException {
 		IFolder folder= jproject.getProject().getFolder(containerName);
 		removeFromClasspath(jproject, folder.getFullPath());
 		folder.delete(true, null);
 	}

 	/**
 	 * Adds a library entry to a IJavaProject.
 	 * @param jproject
 	 * @param path
 	 * @return the package fragment root of the new library
 	 * @throws JavaModelException
 	 */
 	public static IPackageFragmentRoot addLibrary(IJavaProject jproject, IPath path) throws JavaModelException {
 		return addLibrary(jproject, path, null, null);
 	}

 	/**
 	 * Adds a library entry with source attchment to a IJavaProject.
 	 * @param jproject
 	 * @param path
 	 * @param sourceAttachPath
 	 * @param sourceAttachRoot
 	 * @return the package fragment root of the new library
 	 * @throws JavaModelException
 	 */
 	public static IPackageFragmentRoot addLibrary(IJavaProject jproject, IPath path, IPath sourceAttachPath, IPath sourceAttachRoot) throws JavaModelException {
 		IClasspathEntry cpe= JavaCore.newLibraryEntry(path, sourceAttachPath, sourceAttachRoot);
 		addToClasspath(jproject, cpe);
 		return jproject.getPackageFragmentRoot(path.toString());
 	}

 	/**
 	 * Copies the library into the project and adds it as library entry.
 	 * @param jproject
 	 * @param jarPath
 	 * @param sourceAttachPath
 	 * @param sourceAttachRoot
 	 * @return the package fragment root of the new library
 	 * @throws IOException
 	 * @throws CoreException
 	 */
 	public static IPackageFragmentRoot addLibraryWithImport(IJavaProject jproject, IPath jarPath, IPath sourceAttachPath, IPath sourceAttachRoot) throws IOException, CoreException {
 		IProject project= jproject.getProject();
 		IFile newFile= project.getFile(jarPath.lastSegment());
 		try (InputStream inputStream = new FileInputStream(jarPath.toFile())) {
 			newFile.create(inputStream, true, null);
 		}
 		return addLibrary(jproject, newFile.getFullPath(), sourceAttachPath, sourceAttachRoot);
 	}


 	/**
 	 * Adds a variable entry with source attachment to a IJavaProject.
 	 * Can return null if variable can not be resolved.
 	 * @param jproject
 	 * @param path
 	 * @param sourceAttachPath
 	 * @param sourceAttachRoot
 	 * @return the package fragment root of the new variable entry
 	 * @throws JavaModelException
 	 */
 	public static IPackageFragmentRoot addVariableEntry(IJavaProject jproject, IPath path, IPath sourceAttachPath, IPath sourceAttachRoot) throws JavaModelException {
 		IClasspathEntry cpe= JavaCore.newVariableEntry(path, sourceAttachPath, sourceAttachRoot);
 		addToClasspath(jproject, cpe);
 		IPath resolvedPath= JavaCore.getResolvedVariablePath(path);
 		if (resolvedPath != null) {
 			return jproject.getPackageFragmentRoot(resolvedPath.toString());
 		}
 		return null;
 	}

 	/**
 	 * Adds a container entry to the specified java project
 	 * @param project
 	 * @param container
 	 * @throws JavaModelException
 	 */
 	public static void addContainerEntry(IJavaProject project, IPath container) throws JavaModelException {
 		IClasspathEntry cpe = JavaCore.newContainerEntry(container, false);
 		addToClasspath(project, cpe);
 	}

 	/**
 	 * Sets the given compiler compliance on the given {@link IJavaProject}
 	 * <br><br>
 	 * See {@link JavaCore#VERSION_1_4}, {@link JavaCore#VERSION_1_5}, {@link JavaCore#VERSION_1_6},
 	 * {@link JavaCore#VERSION_1_7} and {@link JavaCore#VERSION_1_8} for more information on accepted compliances
 	 *
 	 * @param project
 	 * @param compliance
 	 */
 	public static void setCompliance(IJavaProject project, String compliance) {
 		Map<String, String> map = JavaCore.getOptions();
 		map.put(JavaCore.COMPILER_COMPLIANCE, compliance);
 		map.put(JavaCore.COMPILER_SOURCE, compliance);
 		map.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, compliance);
 		project.setOptions(map);
 	}

 	/**
 	 * Updates the compiler compliance project setting for the given project to match the given EE.
 	 * I.e. J2SE-1.5 will set a 1.5 compliance for the compiler and the source level.
 	 * @param project
 	 * @param ee
 	 */
 	public static void updateCompliance(IJavaProject project, String ee) {
 		if(J2SE_1_4_EE_NAME.equals(ee)) {
 			setCompliance(project, JavaCore.VERSION_1_4);
 		}
 		else if(J2SE_1_5_EE_NAME.equals(ee)) {
 			setCompliance(project, JavaCore.VERSION_1_5);
 		}
 		else if(JAVA_SE_1_7_EE_NAME.equals(ee)) {
 			setCompliance(project, JavaCore.VERSION_1_7);
 		}
 		else if(JAVA_SE_1_8_EE_NAME.equals(ee)) {
 			setCompliance(project, JavaCore.VERSION_1_8);
 		}
 	}

 	/**
 	 * Adds a required project entry.
 	 * @param jproject
 	 * @param required
 	 * @throws JavaModelException
 	 */
 	public static void addRequiredProject(IJavaProject jproject, IJavaProject required) throws JavaModelException {
 		IClasspathEntry cpe= JavaCore.newProjectEntry(required.getProject().getFullPath());
 		addToClasspath(jproject, cpe);
 	}

 	/**
 	 * Removes a specified path form the specified java project
 	 * @param jproject
 	 * @param path
 	 * @throws JavaModelException
 	 */
 	public static void removeFromClasspath(IJavaProject jproject, IPath path) throws JavaModelException {
 		IClasspathEntry[] oldEntries= jproject.getRawClasspath();
 		int nEntries= oldEntries.length;
 		ArrayList<IClasspathEntry> list= new ArrayList<IClasspathEntry>(nEntries);
 		for (int i= 0 ; i < nEntries ; i++) {
 			IClasspathEntry curr= oldEntries[i];
 			if (!path.equals(curr.getPath())) {
 				list.add(curr);
 			}
 		}
 		IClasspathEntry[] newEntries= list.toArray(new IClasspathEntry[list.size()]);
 		jproject.setRawClasspath(newEntries, null);
 	}

 	/**
 	 * Adds the specified classpath entry to the specified java project
 	 * @param jproject
 	 * @param cpe
 	 * @throws JavaModelException
 	 */
 	public static void addToClasspath(IJavaProject jproject, IClasspathEntry cpe) throws JavaModelException {
 		IClasspathEntry[] oldEntries= jproject.getRawClasspath();
 		ArrayList<IClasspathEntry> entries = new ArrayList<IClasspathEntry>(oldEntries.length);
 		for (int i= 0; i < oldEntries.length; i++) {
 			if (oldEntries[i].equals(cpe)) {
 				return;
 			}
 			IPath oldpath = oldEntries[i].getPath();
 			if(JRE_CONTAINER_NAME.equals(oldpath.segment(0)) && JRE_CONTAINER_NAME.equals(cpe.getPath().segment(0))) {
 				continue;
 			}
 			entries.add(oldEntries[i]);
 		}
 		entries.add(cpe);
 		jproject.setRawClasspath(entries.toArray(new IClasspathEntry[entries.size()]), null);
 	}


 	/**
 	 * Adds the specified nature to the specified project
 	 * @param proj
 	 * @param natureId
 	 * @param monitor
 	 * @throws CoreException
 	 */
 	private static void addNatureToProject(IProject proj, String natureId, IProgressMonitor monitor) throws CoreException {
 		IProjectDescription description = proj.getDescription();
 		String[] prevNatures= description.getNatureIds();
 		String[] newNatures= new String[prevNatures.length + 1];
 		System.arraycopy(prevNatures, 0, newNatures, 0, prevNatures.length);
 		newNatures[prevNatures.length]= natureId;
 		description.setNatureIds(newNatures);
 		proj.setDescription(description, monitor);
 	}

 	/**
 	 * Imports files from the specified zip to the specified destination
 	 * @param srcZipFile
 	 * @param destPath
 	 * @param monitor
 	 * @throws InvocationTargetException
 	 */
 	private static void importFilesFromZip(ZipFile srcZipFile, IPath destPath, IProgressMonitor monitor) throws InvocationTargetException {
 		ZipFileStructureProvider structureProvider=	new ZipFileStructureProvider(srcZipFile);
 		try {
 			ImportOperation op= new ImportOperation(destPath, structureProvider.getRoot(), structureProvider, new ImportOverwriteQuery());
 			op.run(monitor);
 		} catch (InterruptedException e) {
 			// should not happen
 		}
 	}

 	/**
 	 * Imports files from the specified root dir into the specified path
 	 * @param rootDir
 	 * @param destPath
 	 * @param monitor
 	 * @throws InvocationTargetException
 	 * @throws IOException
 	 */
 	public static void importFilesFromDirectory(File rootDir, IPath destPath, IProgressMonitor monitor) throws InvocationTargetException, IOException {
 		IImportStructureProvider structureProvider = FileSystemStructureProvider.INSTANCE;
 		List<File> files = new ArrayList<>(100);
 		addJavaFiles(rootDir, files);
 		try {
 			ImportOperation op= new ImportOperation(destPath, rootDir, structureProvider, new ImportOverwriteQuery(), files);
 			op.setCreateContainerStructure(false);
 			op.run(monitor);
 			IStatus status = op.getStatus();
 			if (!status.isOK()) {
 				CoreException e = new CoreException(status);
 				throw new InvocationTargetException(e, "Import operation encountered problems");
 			}
 		} catch (InterruptedException e) {
 			throw new InvocationTargetException(e, "Interrupted during files import");
 		}
 	}

 	/**
 	 * Imports the specified file into the specified path
 	 * @param file
 	 * @param destPath
 	 * @param monitor
 	 * @throws InvocationTargetException
 	 */
 	public static void importFile(File file, IPath destPath, IProgressMonitor monitor) throws InvocationTargetException {
 		IImportStructureProvider structureProvider = FileSystemStructureProvider.INSTANCE;
 		List<File> files = new ArrayList<File>(1);
 		files.add(file);
 		try {
 			ImportOperation op= new ImportOperation(destPath, file.getParentFile(), structureProvider, new ImportOverwriteQuery(), files);
 			op.setCreateContainerStructure(false);
 			op.run(monitor);
 		} catch (InterruptedException e) {
 			// should not happen
 		}
 	}

 	/**
 	 * Recursively adds files from the specified dir to the provided list
 	 * @param dir
 	 * @param collection
 	 * @throws IOException
 	 */
 	private static void addJavaFiles(File dir, List<File> collection) throws IOException {
 		File[] files = dir.listFiles();
 		if(files != null) {
 			List<File> subDirs = new ArrayList<File>(2);
 			for (int i = 0; i < files.length; i++) {
 				if (files[i].isFile()) {
 					collection.add(files[i]);
 				} else if (files[i].isDirectory() && files[i].getName().indexOf("CVS") < 0) {
 					subDirs.add(files[i]);
 				}
 			}
 			Iterator<File> iter = subDirs.iterator();
 			while (iter.hasNext()) {
 				File subDir = iter.next();
 				addJavaFiles(subDir, collection);
 			}
 		}
 	}

 	/**
 	 * Static class for an <code>IOverwriteQuery</code> implementation
 	 */
 	private static class ImportOverwriteQuery implements IOverwriteQuery {
 		/**
 		 * @see org.eclipse.ui.dialogs.IOverwriteQuery#queryOverwrite(java.lang.String)
 		 */
 		@Override
 		public String queryOverwrite(String file) {
 			return ALL;
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2015 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* This is an implementation of an early-draft specification developed under the Java
	* Community Process (JCP) and is made available for testing and evaluation purposes
	* only. The code is not compatible with any specification of the JCP.
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	* Jesper S. Møller - bug 422029: [1.8] Enable debug evaluation support for default methods
	*******************************************************************************/
	package org.eclipse.jdt.debug.testplugin;

	import java.io.File;
	import java.io.FileInputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.lang.reflect.InvocationTargetException;
	import java.util.ArrayList;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;
	import java.util.zip.ZipFile;

	import org.eclipse.core.resources.IContainer;
	import org.eclipse.core.resources.IFile;
	import org.eclipse.core.resources.IFolder;
	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.resources.IProjectDescription;
	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.resources.IWorkspaceRoot;
	import org.eclipse.core.resources.ResourcesPlugin;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IPath;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.Path;
	import org.eclipse.jdt.core.IClasspathEntry;
	import org.eclipse.jdt.core.IJavaProject;
	import org.eclipse.jdt.core.IPackageFragmentRoot;
	import org.eclipse.jdt.core.JavaCore;
	import org.eclipse.jdt.core.JavaModelException;
	import org.eclipse.jdt.internal.core.ClasspathEntry;
	import org.eclipse.ui.dialogs.IOverwriteQuery;
	import org.eclipse.ui.wizards.datatransfer.FileSystemStructureProvider;
	import org.eclipse.ui.wizards.datatransfer.IImportStructureProvider;
	import org.eclipse.ui.wizards.datatransfer.ImportOperation;
	import org.eclipse.ui.wizards.datatransfer.ZipFileStructureProvider;

	/**
	* Helper methods to set up a IJavaProject.
	*/
	public class JavaProjectHelper {

	public static final String SRC_DIR = "src";
	public static final String BIN_DIR = "bin";
	public static final String J2SE_1_4_EE_NAME = "J2SE-1.4";
	public static final String J2SE_1_5_EE_NAME = "J2SE-1.5";
	public static final String JAVA_SE_1_6_EE_NAME = "JavaSE-1.6";
	public static final String JAVA_SE_1_7_EE_NAME = "JavaSE-1.7";
	public static final String JAVA_SE_1_8_EE_NAME = "JavaSE-1.8";

	/**
	* path to the test src for 'testprograms'
	*/
	public static final IPath TEST_SRC_DIR= new Path("testprograms");

	/**
	* path to the 1.5 test source
	*/
	public static final IPath TEST_1_5_SRC_DIR= new Path("testsource-j2se-1.5");
	/**
	* path to the 1.7 test source
	*/
	public static final IPath TEST_1_7_SRC_DIR= new Path("java7");
	/**
	* path to the 1.8 test source
	*/
	public static final IPath TEST_1_8_SRC_DIR= new Path("java8");

	/**
	* path to the compiler error java file
	*/
	public static final IPath TEST_COMPILE_ERROR = new Path("testresources/CompilationError.java");

	public static final String JRE_CONTAINER_NAME = "org.eclipse.jdt.launching.JRE_CONTAINER";


	/**
	* Returns if the currently running VM is version compatible with Java 8
	*
	* @return <code>true</code> if a Java 8 (or greater) VM is running <code>false</code> otherwise
	*/
	public static boolean isJava8Compatible() {
	return isCompatible(8);
	}
	/**
	* Returns if the currently running VM is version compatible with Java 7
	*
	* @return <code>true</code> if a Java 7 (or greater) VM is running <code>false</code> otherwise
	*/
	public static boolean isJava7Compatible() {
	return isCompatible(7);
	}

	/**
	* Returns if the currently running VM is version compatible with Java 6
	*
	* @return <code>true</code> if a Java 6 (or greater) VM is running <code>false</code> otherwise
	*/
	public static boolean isJava6Compatible() {
	return isCompatible(6);
	}

	/**
	* Returns if the currently running VM is version compatible with Java 5
	*
	* @return <code>true</code> if a Java 5 (or greater) VM is running <code>false</code> otherwise
	*/
	public static boolean isJava5Compatible() {
	return isCompatible(5);
	}

	/**
	* Returns if the current running system is compatible with the given Java minor version
	*
	* @param ver the version to test - either 4, 5, 6, 7 or 8
	* @return <code>true</code> if compatible <code>false</code> otherwise
	*/
	static boolean isCompatible(int ver) {
	String version = System.getProperty("java.specification.version");
	if (version != null) {
	String[] nums = version.split("\\.");
	if (nums.length == 2) {
	try {
	int major = Integer.parseInt(nums[0]);
	int minor = Integer.parseInt(nums[1]);
	if (major >= 1) {
	if (minor >= ver) {
	return true;
	}
	}
	} catch (NumberFormatException e) {
	}
	}
	}
	return false;
	}

	/**
	* Creates a new {@link IProject} with the given name unless the project already exists. If it already exists
	* the project is refreshed and opened (if closed)
	*
	* @param pname the desired name for the project
	* @return the new {@link IProject} handle
	* @throws CoreException
	*/
	public static IProject createProject(String pname) throws CoreException {
	IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
	IProject project = root.getProject(pname);
	if (!project.exists()) {
	project.create(null);
	} else {
	project.refreshLocal(IResource.DEPTH_INFINITE, null);
	}
	if (!project.isOpen()) {
	project.open(null);
	}
	return project;
	}

	/**
	* creates a java project with the specified name and output folder
	* @param projectName
	* @param binFolderName
	* @return a new java project
	* @throws CoreException
	*/
	public static IJavaProject createJavaProject(String projectName, String binFolderName) throws CoreException {
	IProject project = createProject(projectName);
	IPath outputLocation;
	if (binFolderName != null && binFolderName.length() > 0) {
	IFolder binFolder= project.getFolder(binFolderName);
	if (!binFolder.exists()) {
	binFolder.create(false, true, null);
	}
	outputLocation= binFolder.getFullPath();
	} else {
	outputLocation= project.getFullPath();
	}
	if (!project.hasNature(JavaCore.NATURE_ID)) {
	addNatureToProject(project, JavaCore.NATURE_ID, null);
	}
	IJavaProject jproject= JavaCore.create(project);
	jproject.setOutputLocation(outputLocation, null);
	jproject.setRawClasspath(new IClasspathEntry[0], null);
	return jproject;
	}

	/**
	* Creates a new Java project with the specified name
	* @param projectName
	* @return a new java project with the specified name
	* @throws CoreException
	*/
	public static IJavaProject createJavaProject(String projectName) throws CoreException {
	IProject project = createProject(projectName);
	if (!project.hasNature(JavaCore.NATURE_ID)) {
	addNatureToProject(project, JavaCore.NATURE_ID, null);
	}
	IJavaProject jproject= JavaCore.create(project);
	jproject.setRawClasspath(new IClasspathEntry[0], null);
	return jproject;
	}

	/**
	* deletes a java project
	* @param jproject
	* @throws CoreException
	*/
	public static void delete(IJavaProject jproject) throws CoreException {
	jproject.setRawClasspath(new ClasspathEntry[0], jproject.getProject().getFullPath(), null);
	jproject.getProject().delete(true, true, null);
	}

	/**
	* Adds a new source container specified by the container name to the source path of the specified project
	* @param jproject
	* @param containerName
	* @return the package fragment root of the container name
	* @throws CoreException
	*/
	public static IPackageFragmentRoot addSourceContainer(IJavaProject jproject, String containerName) throws CoreException {
	IProject project= jproject.getProject();
	IContainer container= null;
	if (containerName == null \|\| containerName.length() == 0) {
	container= project;
	} else {
	IFolder folder= project.getFolder(containerName);
	if (!folder.exists()) {
	folder.create(false, true, null);
	}
	container= folder;
	}
	IPackageFragmentRoot root= jproject.getPackageFragmentRoot(container);

	IClasspathEntry cpe= JavaCore.newSourceEntry(root.getPath());
	addToClasspath(jproject, cpe);
	return root;
	}

	/**
	* Adds a source container to a IJavaProject.
	* @param jproject
	* @param containerName
	* @param outputName
	* @return the package fragment root of the new source container
	* @throws CoreException
	*/
	public static IPackageFragmentRoot addSourceContainer(IJavaProject jproject, String containerName, String outputName) throws CoreException {
	IProject project= jproject.getProject();
	IContainer container= null;
	if (containerName == null \|\| containerName.length() == 0) {
	container= project;
	} else {
	IFolder folder= project.getFolder(containerName);
	if (!folder.exists()) {
	folder.create(false, true, null);
	}
	container= folder;
	}
	IPackageFragmentRoot root= jproject.getPackageFragmentRoot(container);

	IFolder output = null;
	if (outputName!= null) {
	output = project.getFolder(outputName);
	if (!output.exists()) {
	output.create(false, true, null);
	}
	}

	IClasspathEntry cpe= JavaCore.newSourceEntry(root.getPath(), new IPath[0], output.getFullPath());

	addToClasspath(jproject, cpe);
	return root;
	}

	/**
	* Adds a source container to a IJavaProject and imports all files contained
	* in the given Zip file.
	* @param jproject
	* @param containerName
	* @param zipFile
	* @return the package fragment root of the new source container
	* @throws InvocationTargetException
	* @throws CoreException
	*/
	public static IPackageFragmentRoot addSourceContainerWithImport(IJavaProject jproject, String containerName, ZipFile zipFile) throws InvocationTargetException, CoreException {
	IPackageFragmentRoot root= addSourceContainer(jproject, containerName);
	importFilesFromZip(zipFile, root.getPath(), null);
	return root;
	}

	/**
	* Removes a source folder from a IJavaProject.
	* @param jproject
	* @param containerName
	* @throws CoreException
	*/
	public static void removeSourceContainer(IJavaProject jproject, String containerName) throws CoreException {
	IFolder folder= jproject.getProject().getFolder(containerName);
	removeFromClasspath(jproject, folder.getFullPath());
	folder.delete(true, null);
	}

	/**
	* Adds a library entry to a IJavaProject.
	* @param jproject
	* @param path
	* @return the package fragment root of the new library
	* @throws JavaModelException
	*/
	public static IPackageFragmentRoot addLibrary(IJavaProject jproject, IPath path) throws JavaModelException {
	return addLibrary(jproject, path, null, null);
	}

	/**
	* Adds a library entry with source attchment to a IJavaProject.
	* @param jproject
	* @param path
	* @param sourceAttachPath
	* @param sourceAttachRoot
	* @return the package fragment root of the new library
	* @throws JavaModelException
	*/
	public static IPackageFragmentRoot addLibrary(IJavaProject jproject, IPath path, IPath sourceAttachPath, IPath sourceAttachRoot) throws JavaModelException {
	IClasspathEntry cpe= JavaCore.newLibraryEntry(path, sourceAttachPath, sourceAttachRoot);
	addToClasspath(jproject, cpe);
	return jproject.getPackageFragmentRoot(path.toString());
	}

	/**
	* Copies the library into the project and adds it as library entry.
	* @param jproject
	* @param jarPath
	* @param sourceAttachPath
	* @param sourceAttachRoot
	* @return the package fragment root of the new library
	* @throws IOException
	* @throws CoreException
	*/
	public static IPackageFragmentRoot addLibraryWithImport(IJavaProject jproject, IPath jarPath, IPath sourceAttachPath, IPath sourceAttachRoot) throws IOException, CoreException {
	IProject project= jproject.getProject();
	IFile newFile= project.getFile(jarPath.lastSegment());
	try (InputStream inputStream = new FileInputStream(jarPath.toFile())) {
	newFile.create(inputStream, true, null);
	}
	return addLibrary(jproject, newFile.getFullPath(), sourceAttachPath, sourceAttachRoot);
	}


	/**
	* Adds a variable entry with source attachment to a IJavaProject.
	* Can return null if variable can not be resolved.
	* @param jproject
	* @param path
	* @param sourceAttachPath
	* @param sourceAttachRoot
	* @return the package fragment root of the new variable entry
	* @throws JavaModelException
	*/
	public static IPackageFragmentRoot addVariableEntry(IJavaProject jproject, IPath path, IPath sourceAttachPath, IPath sourceAttachRoot) throws JavaModelException {
	IClasspathEntry cpe= JavaCore.newVariableEntry(path, sourceAttachPath, sourceAttachRoot);
	addToClasspath(jproject, cpe);
	IPath resolvedPath= JavaCore.getResolvedVariablePath(path);
	if (resolvedPath != null) {
	return jproject.getPackageFragmentRoot(resolvedPath.toString());
	}
	return null;
	}

	/**
	* Adds a container entry to the specified java project
	* @param project
	* @param container
	* @throws JavaModelException
	*/
	public static void addContainerEntry(IJavaProject project, IPath container) throws JavaModelException {
	IClasspathEntry cpe = JavaCore.newContainerEntry(container, false);
	addToClasspath(project, cpe);
	}

	/**
	* Sets the given compiler compliance on the given {@link IJavaProject}
	* <br><br>
	* See {@link JavaCore#VERSION_1_4}, {@link JavaCore#VERSION_1_5}, {@link JavaCore#VERSION_1_6},
	* {@link JavaCore#VERSION_1_7} and {@link JavaCore#VERSION_1_8} for more information on accepted compliances
	*
	* @param project
	* @param compliance
	*/
	public static void setCompliance(IJavaProject project, String compliance) {
	Map<String, String> map = JavaCore.getOptions();
	map.put(JavaCore.COMPILER_COMPLIANCE, compliance);
	map.put(JavaCore.COMPILER_SOURCE, compliance);
	map.put(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, compliance);
	project.setOptions(map);
	}

	/**
	* Updates the compiler compliance project setting for the given project to match the given EE.
	* I.e. J2SE-1.5 will set a 1.5 compliance for the compiler and the source level.
	* @param project
	* @param ee
	*/
	public static void updateCompliance(IJavaProject project, String ee) {
	if(J2SE_1_4_EE_NAME.equals(ee)) {
	setCompliance(project, JavaCore.VERSION_1_4);
	}
	else if(J2SE_1_5_EE_NAME.equals(ee)) {
	setCompliance(project, JavaCore.VERSION_1_5);
	}
	else if(JAVA_SE_1_7_EE_NAME.equals(ee)) {
	setCompliance(project, JavaCore.VERSION_1_7);
	}
	else if(JAVA_SE_1_8_EE_NAME.equals(ee)) {
	setCompliance(project, JavaCore.VERSION_1_8);
	}
	}

	/**
	* Adds a required project entry.
	* @param jproject
	* @param required
	* @throws JavaModelException
	*/
	public static void addRequiredProject(IJavaProject jproject, IJavaProject required) throws JavaModelException {
	IClasspathEntry cpe= JavaCore.newProjectEntry(required.getProject().getFullPath());
	addToClasspath(jproject, cpe);
	}

	/**
	* Removes a specified path form the specified java project
	* @param jproject
	* @param path
	* @throws JavaModelException
	*/
	public static void removeFromClasspath(IJavaProject jproject, IPath path) throws JavaModelException {
	IClasspathEntry[] oldEntries= jproject.getRawClasspath();
	int nEntries= oldEntries.length;
	ArrayList<IClasspathEntry> list= new ArrayList<IClasspathEntry>(nEntries);
	for (int i= 0 ; i < nEntries ; i++) {
	IClasspathEntry curr= oldEntries[i];
	if (!path.equals(curr.getPath())) {
	list.add(curr);
	}
	}
	IClasspathEntry[] newEntries= list.toArray(new IClasspathEntry[list.size()]);
	jproject.setRawClasspath(newEntries, null);
	}

	/**
	* Adds the specified classpath entry to the specified java project
	* @param jproject
	* @param cpe
	* @throws JavaModelException
	*/
	public static void addToClasspath(IJavaProject jproject, IClasspathEntry cpe) throws JavaModelException {
	IClasspathEntry[] oldEntries= jproject.getRawClasspath();
	ArrayList<IClasspathEntry> entries = new ArrayList<IClasspathEntry>(oldEntries.length);
	for (int i= 0; i < oldEntries.length; i++) {
	if (oldEntries[i].equals(cpe)) {
	return;
	}
	IPath oldpath = oldEntries[i].getPath();
	if(JRE_CONTAINER_NAME.equals(oldpath.segment(0)) && JRE_CONTAINER_NAME.equals(cpe.getPath().segment(0))) {
	continue;
	}
	entries.add(oldEntries[i]);
	}
	entries.add(cpe);
	jproject.setRawClasspath(entries.toArray(new IClasspathEntry[entries.size()]), null);
	}


	/**
	* Adds the specified nature to the specified project
	* @param proj
	* @param natureId
	* @param monitor
	* @throws CoreException
	*/
	private static void addNatureToProject(IProject proj, String natureId, IProgressMonitor monitor) throws CoreException {
	IProjectDescription description = proj.getDescription();
	String[] prevNatures= description.getNatureIds();
	String[] newNatures= new String[prevNatures.length + 1];
	System.arraycopy(prevNatures, 0, newNatures, 0, prevNatures.length);
	newNatures[prevNatures.length]= natureId;
	description.setNatureIds(newNatures);
	proj.setDescription(description, monitor);
	}

	/**
	* Imports files from the specified zip to the specified destination
	* @param srcZipFile
	* @param destPath
	* @param monitor
	* @throws InvocationTargetException
	*/
	private static void importFilesFromZip(ZipFile srcZipFile, IPath destPath, IProgressMonitor monitor) throws InvocationTargetException {
	ZipFileStructureProvider structureProvider= new ZipFileStructureProvider(srcZipFile);
	try {
	ImportOperation op= new ImportOperation(destPath, structureProvider.getRoot(), structureProvider, new ImportOverwriteQuery());
	op.run(monitor);
	} catch (InterruptedException e) {
	// should not happen
	}
	}

	/**
	* Imports files from the specified root dir into the specified path
	* @param rootDir
	* @param destPath
	* @param monitor
	* @throws InvocationTargetException
	* @throws IOException
	*/
	public static void importFilesFromDirectory(File rootDir, IPath destPath, IProgressMonitor monitor) throws InvocationTargetException, IOException {
	IImportStructureProvider structureProvider = FileSystemStructureProvider.INSTANCE;
	List<File> files = new ArrayList<>(100);
	addJavaFiles(rootDir, files);
	try {
	ImportOperation op= new ImportOperation(destPath, rootDir, structureProvider, new ImportOverwriteQuery(), files);
	op.setCreateContainerStructure(false);
	op.run(monitor);
	IStatus status = op.getStatus();
	if (!status.isOK()) {
	CoreException e = new CoreException(status);
	throw new InvocationTargetException(e, "Import operation encountered problems");
	}
	} catch (InterruptedException e) {
	throw new InvocationTargetException(e, "Interrupted during files import");
	}
	}

	/**
	* Imports the specified file into the specified path
	* @param file
	* @param destPath
	* @param monitor
	* @throws InvocationTargetException
	*/
	public static void importFile(File file, IPath destPath, IProgressMonitor monitor) throws InvocationTargetException {
	IImportStructureProvider structureProvider = FileSystemStructureProvider.INSTANCE;
	List<File> files = new ArrayList<File>(1);
	files.add(file);
	try {
	ImportOperation op= new ImportOperation(destPath, file.getParentFile(), structureProvider, new ImportOverwriteQuery(), files);
	op.setCreateContainerStructure(false);
	op.run(monitor);
	} catch (InterruptedException e) {
	// should not happen
	}
	}

	/**
	* Recursively adds files from the specified dir to the provided list
	* @param dir
	* @param collection
	* @throws IOException
	*/
	private static void addJavaFiles(File dir, List<File> collection) throws IOException {
	File[] files = dir.listFiles();
	if(files != null) {
	List<File> subDirs = new ArrayList<File>(2);
	for (int i = 0; i < files.length; i++) {
	if (files[i].isFile()) {
	collection.add(files[i]);
	} else if (files[i].isDirectory() && files[i].getName().indexOf("CVS") < 0) {
	subDirs.add(files[i]);
	}
	}
	Iterator<File> iter = subDirs.iterator();
	while (iter.hasNext()) {
	File subDir = iter.next();
	addJavaFiles(subDir, collection);
	}
	}
	}

	/**
	* Static class for an <code>IOverwriteQuery</code> implementation
	*/
	private static class ImportOverwriteQuery implements IOverwriteQuery {
	/**
	* @see org.eclipse.ui.dialogs.IOverwriteQuery#queryOverwrite(java.lang.String)
	*/
	@Override
	public String queryOverwrite(String file) {
	return ALL;
	}
	}
	}