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

 package org.eclipse.jdt.debug.testplugin;

 /**********************************************************************
 Copyright (c) 2000, 2002 IBM Corp. and others.
 All rights reserved. This program and the accompanying materials
 are made available under the terms of the Common Public License v0.5
 which accompanies this distribution, and is available at
 http://www.eclipse.org/legal/cpl-v05.html

 Contributors:
     IBM Corporation - Initial implementation
 **********************************************************************/

 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.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.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 IPath TEST_SRC_DIR= new Path("testprograms");

 	/**
 	 * Creates a IJavaProject.
 	 */
 	public static IJavaProject createJavaProject(String projectName, String binFolderName) throws CoreException {
 		IWorkspaceRoot root= ResourcesPlugin.getWorkspace().getRoot();
 		IProject project= root.getProject(projectName);
 		if (!project.exists()) {
 			project.create(null);
 		} else {
 			project.refreshLocal(IResource.DEPTH_INFINITE, null);
 		}

 		if (!project.isOpen()) {
 			project.open(null);
 		}

 		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;
 	}

 	/**
 	 * Removes a IJavaProject.
 	 */
 	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 source container to a IJavaProject.
 	 */
 	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 and imports all files contained
 	 * in the given Zip file.
 	 */
 	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.
 	 */
 	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.
 	 */
 	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.
 	 */
 	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.
 	 */
 	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());
 		InputStream inputStream= null;
 		try {
 			inputStream= new FileInputStream(jarPath.toFile());
 			newFile.create(inputStream, true, null);
 		} finally {
 			if (inputStream != null) {
 				try { inputStream.close(); } catch (IOException e) { }
 			}
 		}
 		return addLibrary(jproject, newFile.getFullPath(), sourceAttachPath, sourceAttachRoot);
 	}


 	/**
 	 * Adds a variable entry with source attchment to a IJavaProject.
 	 * Can return null if variable can not be resolved.
 	 */
 	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 required project entry.
 	 */
 	public static void addRequiredProject(IJavaProject jproject, IJavaProject required) throws JavaModelException {
 		IClasspathEntry cpe= JavaCore.newProjectEntry(required.getProject().getFullPath());
 		addToClasspath(jproject, cpe);
 	}

 	public static void removeFromClasspath(IJavaProject jproject, IPath path) throws JavaModelException {
 		IClasspathEntry[] oldEntries= jproject.getRawClasspath();
 		int nEntries= oldEntries.length;
 		ArrayList list= new ArrayList(nEntries);
 		for (int i= 0 ; i < nEntries ; i++) {
 			IClasspathEntry curr= oldEntries[i];
 			if (!path.equals(curr.getPath())) {
 				list.add(curr);
 			}
 		}
 		IClasspathEntry[] newEntries= (IClasspathEntry[])list.toArray(new IClasspathEntry[list.size()]);
 		jproject.setRawClasspath(newEntries, null);
 	}

 	private static void addToClasspath(IJavaProject jproject, IClasspathEntry cpe) throws JavaModelException {
 		IClasspathEntry[] oldEntries= jproject.getRawClasspath();
 		for (int i= 0; i < oldEntries.length; i++) {
 			if (oldEntries[i].equals(cpe)) {
 				return;
 			}
 		}
 		int nEntries= oldEntries.length;
 		IClasspathEntry[] newEntries= new IClasspathEntry[nEntries + 1];
 		System.arraycopy(oldEntries, 0, newEntries, 0, nEntries);
 		newEntries[nEntries]= cpe;
 		jproject.setRawClasspath(newEntries, null);
 	}


 	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);
 	}

 	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
 		}
 	}

 	public static void importFilesFromDirectory(File rootDir, IPath destPath, IProgressMonitor monitor) throws InvocationTargetException, IOException {
 		IImportStructureProvider structureProvider = FileSystemStructureProvider.INSTANCE;
 		List files = new ArrayList(100);
 		addJavaFiles(rootDir, files);
 		try {
 			ImportOperation op= new ImportOperation(destPath, rootDir, structureProvider, new ImportOverwriteQuery(), files);
 			op.setCreateContainerStructure(false);
 			op.run(monitor);
 		} catch (InterruptedException e) {
 			// should not happen
 		}
 	}

 	private static void addJavaFiles(File dir, List collection) throws IOException {
 		File[] files = dir.listFiles();
 		List subDirs = new ArrayList(2);
 		for (int i = 0; i < files.length; i++) {
 			if (files[i].isFile()) {
 				collection.add(files[i]);
 			} else if (files[i].isDirectory()) {
 				subDirs.add(files[i]);
 			}
 		}
 		Iterator iter = subDirs.iterator();
 		while (iter.hasNext()) {
 			File subDir = (File)iter.next();
 			addJavaFiles(subDir, collection);
 		}
 	}

 	private static class ImportOverwriteQuery implements IOverwriteQuery {
 		public String queryOverwrite(String file) {
 			return ALL;
 		}
 	}


 }
	package org.eclipse.jdt.debug.testplugin;

	/**********************************************************************
	Copyright (c) 2000, 2002 IBM Corp. and others.
	All rights reserved. This program and the accompanying materials
	are made available under the terms of the Common Public License v0.5
	which accompanies this distribution, and is available at
	http://www.eclipse.org/legal/cpl-v05.html

	Contributors:
	IBM Corporation - Initial implementation
	**********************************************************************/

	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.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.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 IPath TEST_SRC_DIR= new Path("testprograms");

	/**
	* Creates a IJavaProject.
	*/
	public static IJavaProject createJavaProject(String projectName, String binFolderName) throws CoreException {
	IWorkspaceRoot root= ResourcesPlugin.getWorkspace().getRoot();
	IProject project= root.getProject(projectName);
	if (!project.exists()) {
	project.create(null);
	} else {
	project.refreshLocal(IResource.DEPTH_INFINITE, null);
	}

	if (!project.isOpen()) {
	project.open(null);
	}

	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;
	}

	/**
	* Removes a IJavaProject.
	*/
	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 source container to a IJavaProject.
	*/
	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 and imports all files contained
	* in the given Zip file.
	*/
	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.
	*/
	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.
	*/
	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.
	*/
	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.
	*/
	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());
	InputStream inputStream= null;
	try {
	inputStream= new FileInputStream(jarPath.toFile());
	newFile.create(inputStream, true, null);
	} finally {
	if (inputStream != null) {
	try { inputStream.close(); } catch (IOException e) { }
	}
	}
	return addLibrary(jproject, newFile.getFullPath(), sourceAttachPath, sourceAttachRoot);
	}


	/**
	* Adds a variable entry with source attchment to a IJavaProject.
	* Can return null if variable can not be resolved.
	*/
	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 required project entry.
	*/
	public static void addRequiredProject(IJavaProject jproject, IJavaProject required) throws JavaModelException {
	IClasspathEntry cpe= JavaCore.newProjectEntry(required.getProject().getFullPath());
	addToClasspath(jproject, cpe);
	}

	public static void removeFromClasspath(IJavaProject jproject, IPath path) throws JavaModelException {
	IClasspathEntry[] oldEntries= jproject.getRawClasspath();
	int nEntries= oldEntries.length;
	ArrayList list= new ArrayList(nEntries);
	for (int i= 0 ; i < nEntries ; i++) {
	IClasspathEntry curr= oldEntries[i];
	if (!path.equals(curr.getPath())) {
	list.add(curr);
	}
	}
	IClasspathEntry[] newEntries= (IClasspathEntry[])list.toArray(new IClasspathEntry[list.size()]);
	jproject.setRawClasspath(newEntries, null);
	}

	private static void addToClasspath(IJavaProject jproject, IClasspathEntry cpe) throws JavaModelException {
	IClasspathEntry[] oldEntries= jproject.getRawClasspath();
	for (int i= 0; i < oldEntries.length; i++) {
	if (oldEntries[i].equals(cpe)) {
	return;
	}
	}
	int nEntries= oldEntries.length;
	IClasspathEntry[] newEntries= new IClasspathEntry[nEntries + 1];
	System.arraycopy(oldEntries, 0, newEntries, 0, nEntries);
	newEntries[nEntries]= cpe;
	jproject.setRawClasspath(newEntries, null);
	}


	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);
	}

	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
	}
	}

	public static void importFilesFromDirectory(File rootDir, IPath destPath, IProgressMonitor monitor) throws InvocationTargetException, IOException {
	IImportStructureProvider structureProvider = FileSystemStructureProvider.INSTANCE;
	List files = new ArrayList(100);
	addJavaFiles(rootDir, files);
	try {
	ImportOperation op= new ImportOperation(destPath, rootDir, structureProvider, new ImportOverwriteQuery(), files);
	op.setCreateContainerStructure(false);
	op.run(monitor);
	} catch (InterruptedException e) {
	// should not happen
	}
	}

	private static void addJavaFiles(File dir, List collection) throws IOException {
	File[] files = dir.listFiles();
	List subDirs = new ArrayList(2);
	for (int i = 0; i < files.length; i++) {
	if (files[i].isFile()) {
	collection.add(files[i]);
	} else if (files[i].isDirectory()) {
	subDirs.add(files[i]);
	}
	}
	Iterator iter = subDirs.iterator();
	while (iter.hasNext()) {
	File subDir = (File)iter.next();
	addJavaFiles(subDir, collection);
	}
	}

	private static class ImportOverwriteQuery implements IOverwriteQuery {
	public String queryOverwrite(String file) {
	return ALL;
	}
	}


	}