Attachment #96606 for bug #182360

View | Details | Raw Unified | Return to bug 182360
Collapse All | Expand All




        " with ''+''.\n" +
        " \n" +
        " Classpath options:\n" +
        "    -cp -classpath <directories and ZIP archives separated by " + File.pathSeparator + ">\n" +
        "                       specify location for application classes and sources.\n" +
        "                       Each directory or file can specify access rules for\n" +
        "                       types between ''['' and '']'' (e.g. [-X] to forbid\n" +
        "                       access to type X, [~X] to discourage access to type X,\n" +
        "                       [+p/X" + File.pathSeparator + "-p/*] to forbid access to all types in package p\n" +
        "                       but allow access to p/X)\n" +
        "    -bootclasspath <directories and ZIP archives separated by " + File.pathSeparator + ">\n" +
        "                       specify location for system classes. Each directory or\n" +
        "                       file can specify access rules for types between ''[''\n" +
        "                       and '']''\n" +
        "    -sourcepath <directories and ZIP archives separated by " + File.pathSeparator + ">\n" +
        "                       specify location for application sources. Each directory\n" +
        "                       or file can specify access rules for types between ''[''\n" +
        "                       and '']''. Each directory can further specify a specific\n" +

        "                       and '']''; this overrides the general ''-d'' option.\n" +
        "                       .class files created from source files contained in a\n" +
        "                       jar file are put in the user.dir folder in case no\n" +
        "                       general ''-d'' option is specified. ZIP archives cannot\n" +
        "                       override the general ''-d'' option\n" +
        "    -extdirs <directories separated by " + File.pathSeparator + ">\n" +
        "                       specify location for extension ZIP archives\n" +
        "    -endorseddirs <directories separated by " + File.pathSeparator + ">\n" +
        "                       specify location for endorsed ZIP archives\n" +
        "    -d <dir>           destination directory (if omitted, no directory is\n" +
        "                       created); this option can be overridden per source\n" +
		"                       directory\n" +

        " Annotation processing options:\n" + 
        "   These options are meaningful only in a 1.6 environment.\n" + 
        "    -Akey[=value]        options that are passed to annotation processors\n" + 
        "    -processorpath <directories and ZIP archives separated by " + File.pathSeparator + ">\n" + 
        "                         specify locations where to find annotation processors.\n" + 
        "                         If this option is not used, the classpath will be\n" + 
        "                         searched for processors\n" + 

	this.verifier.execute("Y", new String[] {OUTPUT_DIR });
	assertTrue(this.verifier.getExecutionOutput().startsWith("1")); // skip trailing newline
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=182360
public void test281_classpath() {
	runConformTest(
		new String[] {
			"src1/X.java",
			"public class X {\n" +
			"}",
		},
        "\"" + OUTPUT_DIR +  File.separator + "src1/X.java\" -cp Y.java",
        "" /* expectedOutOutputString */,
        "incorrect classpath: Y.java\n",
        false/*shouldFlushOutput*/);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=182360
public void test282_classpath() {
	runConformTest(
		new String[] {
			"src1/X.java",
			"public class X {\n" +
			"}",
		},
        "\"" + OUTPUT_DIR +  File.separator + "src1/X.java\" -cp p/Y.java",
        "" /* expectedOutOutputString */,
        "incorrect classpath: p/Y.java\n",
        false/*shouldFlushOutput*/);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=182360
public void test283_classpath() {
	runConformTest(
		new String[] {
			"src1/X.java",
			"public class X {\n" +
			"}",
		},
        "\"" + OUTPUT_DIR +  File.separator + "src1/X.java\" -cp Y.class",
        "" /* expectedOutOutputString */,
        "incorrect classpath: Y.class\n",
        false/*shouldFlushOutput*/);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=182360
public void test284_classpath() {
	runConformTest(
		new String[] {
			"src1/X.java",
			"public class X {\n" +
			"}",
		},
        "\"" + OUTPUT_DIR +  File.separator + "src1/X.java\" -cp p/Y.class",
        "" /* expectedOutOutputString */,
        "incorrect classpath: p/Y.class\n",
        false/*shouldFlushOutput*/);
}
}




package org.eclipse.jdt.core;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.internal.core.BufferManager;
import org.eclipse.jdt.internal.core.CompilationUnit;
import org.eclipse.jdt.internal.core.DefaultWorkingCopyOwner;

	 */
	public final ICompilationUnit newWorkingCopy(String name, IClasspathEntry[] classpath, IProblemRequestor problemRequestor, IProgressMonitor monitor) throws JavaModelException {
		ExternalJavaProject project = new ExternalJavaProject(classpath);
		IPackageFragment parent = project.getPackageFragmentRoot(project.getProject()).getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME);
		CompilationUnit result = new CompilationUnit((PackageFragment) parent, name, this);
		result.becomeWorkingCopy(problemRequestor, monitor);
		return result;

	 */
	public final ICompilationUnit newWorkingCopy(String name, IClasspathEntry[] classpath, IProgressMonitor monitor) throws JavaModelException {
		ExternalJavaProject project = new ExternalJavaProject(classpath);
		IPackageFragment parent = project.getPackageFragmentRoot(project.getProject()).getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME);
		CompilationUnit result = new CompilationUnit((PackageFragment) parent, name, this);
		result.becomeWorkingCopy(getProblemRequestor(result), monitor);
		return result;




	IPath getOutputLocation() throws JavaModelException;

	/**
	 * Returns a package fragment root for an external library 
	 * (a ZIP archive - e.g. a <code>.jar</code>, a <code>.zip</code> file, etc. -
	 * or - since 3.4 - a class folder) at the specified file system path.
	 * This is a handle-only method.  The underlying <code>java.io.File</code>
	 * may or may not exist. No resource is associated with this local library
	 * package fragment root.

	/**
	 * Returns a package fragment root for the given resource, which
	 * must either be a folder representing the top of a package hierarchy,
	 * or a ZIP archive (e.g. a <code>.jar</code>, a <code>.zip</code> file, etc.)
	 * This is a handle-only method.  The underlying resource may or may not exist. 
	 * 
	 * @param resource the given resource
	 * @return a package fragment root for the given resource, which
	 * must either be a folder representing the top of a package hierarchy,
	 * or a ZIP archive (e.g. a <code>.jar</code>, a <code>.zip</code> file, etc.)
	 */
	IPackageFragmentRoot getPackageFragmentRoot(IResource resource);





import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
import org.eclipse.jdt.internal.compiler.util.SuffixConstants;
import org.eclipse.jdt.internal.core.*;
import org.eclipse.jdt.internal.core.builder.JavaBuilder;
import org.eclipse.jdt.internal.core.builder.State;

	 *	<li>a file with one of the {@link JavaCore#getJavaLikeExtensions()
	 *      Java-like extensions} - the element returned is the corresponding <code>ICompilationUnit</code></li>
	 *	<li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li>
	 *	<li>a ZIP archive (e.g. a <code>.jar</code>, a <code>.zip</code> file, etc.) - the element returned is the corresponding <code>IPackageFragmentRoot</code></li>
	 *	</ul>
	 * <p>
	 * Creating a Java element has the side effect of creating and opening all of the

	 *	<li>a file with one of the {@link JavaCore#getJavaLikeExtensions()
	 *      Java-like extensions} - the element returned is the corresponding <code>ICompilationUnit</code></li>
	 *	<li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li>
	 *	<li>a ZIP archive (e.g. a <code>.jar</code>, a <code>.zip</code> file, etc.) - the element returned is the corresponding <code>IPackageFragmentRoot</code></li>
	 *  <li>a folder - the element returned is the corresponding <code>IPackageFragmentRoot</code>
	 *    	or <code>IPackageFragment</code></li>
	 *  <li>the workspace root resource - the element returned is the <code>IJavaModel</code></li>

	 *	<li>a file with one of the {@link JavaCore#getJavaLikeExtensions()
	 *      Java-like extensions} - the element returned is the corresponding <code>ICompilationUnit</code></li>
	 *	<li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li>
	 *	<li>a ZIP archive (e.g. a <code>.jar</code>, a <code>.zip</code> file, etc.) - the element returned is the corresponding <code>IPackageFragmentRoot</code></li>
	 *  <li>a folder - the element returned is the corresponding <code>IPackageFragmentRoot</code>
	 *    	or <code>IPackageFragment</code></li>
	 *  <li>the workspace root resource - the element returned is the <code>IJavaModel</code></li>

							entry.getExtraAttributes(),
							entry.isExported());
				case IResource.FILE :
					// internal binary archive
						// internal binary archive
						return JavaCore.newLibraryEntry(
								resolvedPath,
								getResolvedVariablePath(entry.getSourceAttachmentPath()),
								getResolvedVariablePath(entry.getSourceAttachmentRootPath()),
								entry.getAccessRules(),
								entry.getExtraAttributes(),
								entry.isExported());
					}
					break;

				case IResource.FOLDER :
					// internal binary folder
					return JavaCore.newLibraryEntry(
							resolvedPath,
							getResolvedVariablePath(entry.getSourceAttachmentPath()),

							entry.getAccessRules(),
							entry.getExtraAttributes(),
							entry.isExported());
				case IResource.FOLDER :
					// internal binary folder
		if (target instanceof File) {
			File externalFile = JavaModel.getFile(target);
			if (externalFile != null) {
				// outside the workspace
				String fileName = externalFile.getName().toLowerCase();
				if (fileName.endsWith(SuffixConstants.SUFFIX_STRING_jar) || fileName.endsWith(SuffixConstants.SUFFIX_STRING_zip)) {
					// external binary archive
					return JavaCore.newLibraryEntry(
							resolvedPath,
							getResolvedVariablePath(entry.getSourceAttachmentPath()),

							entry.getAccessRules(),
							entry.getExtraAttributes(),
							entry.isExported());
			}
		}
		if (target instanceof File) {
			File externalFile = JavaModel.getFile(target);
			if (externalFile != null) {
				// external binary archive
				return JavaCore.newLibraryEntry(
						resolvedPath,
						getResolvedVariablePath(entry.getSourceAttachmentPath()),
						getResolvedVariablePath(entry.getSourceAttachmentRootPath()),
						entry.getAccessRules(),
						entry.getExtraAttributes(),
						entry.isExported());
			} else { 
				// non-existing file
				if (resolvedPath.isAbsolute()){




import org.eclipse.jdt.internal.compiler.parser.Scanner;
import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;
import org.eclipse.jdt.internal.compiler.parser.TerminalTokens;
import org.eclipse.jdt.internal.compiler.util.SuffixConstants;
import org.eclipse.jdt.internal.core.*;
import org.eclipse.jdt.internal.core.util.Messages;


		if (rootPath1 == null || rootPath2 == null) {
			return false;
		}
		String extension1 = rootPath1.getFileExtension();
		String extension2 = rootPath2.getFileExtension();
		if (extension1 != null && (extension1.equalsIgnoreCase(SuffixConstants.EXTENSION_JAR) || extension1.equalsIgnoreCase(SuffixConstants.EXTENSION_ZIP))) {
			return false;
		} 
		if (extension2 != null && (extension2.equalsIgnoreCase(SuffixConstants.EXTENSION_JAR) || extension2.equalsIgnoreCase(SuffixConstants.EXTENSION_ZIP))) {
			return false;
		}
		return rootPath1.isPrefixOf(rootPath2) || rootPath2.isPrefixOf(rootPath1);
	}


Lines 270-276 Link Here

(-)model/org/eclipse/jdt/internal/core/util/HandleFactory.java (-1 / +1 lines)
270	int index = 0;	270	int index = 0;
271	for (int i = 0; i < length; i++) {	271	for (int i = 0; i < length; i++) {
272	IPath path = enclosingProjectsAndJars[i];	272	IPath path = enclosingProjectsAndJars[i];
273	if (!org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(path.lastSegment())) {	273	if (path.segmentCount() == 1) {
274	projects[index++] = this.javaModel.getJavaProject(path.segment(0));	274	projects[index++] = this.javaModel.getJavaProject(path.segment(0));
275	}	275	}
276	}	276	}

Lines 107-113 Link Here

(-)model/org/eclipse/jdt/internal/core/ExternalPackageFragmentRoot.java (-1 / +1 lines)
107		107
108	public IResource resource(PackageFragmentRoot root) {	108	public IResource resource(PackageFragmentRoot root) {
109	if (this.resource == null)	109	if (this.resource == null)
110	return (IResource) (this.resource = JavaModelManager.getExternalManager().getFolder(this.externalPath));	110	return this.resource = JavaModelManager.getExternalManager().getFolder(this.externalPath);
111	return super.resource(root);	111	return super.resource(root);
112	}	112	}
113		113

Lines 77-83 Link Here

(-)model/org/eclipse/jdt/internal/core/ExternalFoldersManager.java (-1 / +1 lines)
77	File externalFolder = externalPath.toFile();	77	File externalFolder = externalPath.toFile();
78	if (externalFolder.isFile())	78	if (externalFolder.isFile())
79	return false;	79	return false;
80	if (org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(externalPath.lastSegment()) && !externalFolder.exists())	80	if (externalPath.getFileExtension() != null/likely a .jar, .zip, .rar or other file/ && !externalFolder.exists())
81	return false;	81	return false;
82	return true;	82	return true;
83	}	83	}

Lines 318-324 Link Here

(-)model/org/eclipse/jdt/internal/core/JavaModel.java (-1 / +1 lines)
318	return target;	318	return target;
319	return getExternalTarget(path, checkResourceExistence);	319	return getExternalTarget(path, checkResourceExistence);
320	}	320	}
321	public static Object getWorkspaceTarget(IPath path) {	321	public static IResource getWorkspaceTarget(IPath path) {
322	if (path == null \|\| path.getDevice() != null)	322	if (path == null \|\| path.getDevice() != null)
323	return null;	323	return null;
324	IWorkspace workspace = ResourcesPlugin.getWorkspace();	324	IWorkspace workspace = ResourcesPlugin.getWorkspace();

Lines 412-418 Link Here

(-)model/org/eclipse/jdt/internal/core/SourceMapper.java (-19 / +15 lines)
412	}	412	}
413	}	413	}
414		414
415	if (Util.isArchiveFileName(this.sourcePath.lastSegment())) {	415	Object target = JavaModel.getTarget(this.sourcePath, true);
		416	if (target instanceof IContainer) {
		417	computeRootPath((IContainer)target, firstLevelPackageNames, containsADefaultPackage, tempRoots);
		418	} else {
416	JavaModelManager manager = JavaModelManager.getJavaModelManager();	419	JavaModelManager manager = JavaModelManager.getJavaModelManager();
417	ZipFile zip = null;	420	ZipFile zip = null;
418	try {	421	try {
Lines 443-453 Link Here
443	} finally {	446	} finally {
444	manager.closeZipFile(zip); // handle null case	447	manager.closeZipFile(zip); // handle null case
445	}	448	}
446	} else {
447	Object target = JavaModel.getTarget(this.sourcePath, true);
448	if (target instanceof IContainer) {
449	computeRootPath((IContainer)target, firstLevelPackageNames, containsADefaultPackage, tempRoots);
450	}
451	}	449	}
452	int size = tempRoots.size();	450	int size = tempRoots.size();
453	if (this.rootPaths != null) {	451	if (this.rootPaths != null) {
Lines 884-890 Link Here
884		882
885	public char[] findSource(String fullName) {	883	public char[] findSource(String fullName) {
886	char[] source = null;	884	char[] source = null;
887	if (Util.isArchiveFileName(this.sourcePath.lastSegment())) {	885	Object target = JavaModel.getTarget(this.sourcePath, true);
		886	if (target instanceof IContainer) {
		887	IResource res = ((IContainer)target).findMember(fullName);
		888	if (res instanceof IFile) {
		889	try {
		890	source = org.eclipse.jdt.internal.core.util.Util.getResourceContentsAsCharArray((IFile)res);
		891	} catch (JavaModelException e) {
		892	// ignore
		893	}
		894	}
		895	} else {
888	// try to get the entry	896	// try to get the entry
889	ZipEntry entry = null;	897	ZipEntry entry = null;
890	ZipFile zip = null;	898	ZipFile zip = null;
Lines 901-918 Link Here
901	} finally {	909	} finally {
902	manager.closeZipFile(zip); // handle null case	910	manager.closeZipFile(zip); // handle null case
903	}	911	}
904	} else {
905	Object target = JavaModel.getTarget(this.sourcePath, true);
906	if (target instanceof IContainer) {
907	IResource res = ((IContainer)target).findMember(fullName);
908	if (res instanceof IFile) {
909	try {
910	source = org.eclipse.jdt.internal.core.util.Util.getResourceContentsAsCharArray((IFile)res);
911	} catch (JavaModelException e) {
912	// ignore
913	}
914	}
915	}
916	}	912	}
917	return source;	913	return source;
918	}	914	}




	public final static String NO_SOURCE_ATTACHMENT = ""; //$NON-NLS-1$

	/**
	 * The resource associated with this root (null for external jar)
	 * (an IResource or a java.io.File (for external jar only))
	 */
	protected IResource resource;
	
/**
 * Constructs a package fragment root which is the root of the java package

		JavaProject parentProject = (JavaProject) getJavaProject();
		try {
			entry = parentProject.getClasspathEntryFor(rootPath);
			if (entry != null) {
				Object target = JavaModel.getTarget(entry.getSourceAttachmentPath(), true);
				if (target != null) {
					return entry;
						IFile file = (IFile) target;
						if (org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(file.getName())){
							return entry;
						}
					} else if (target instanceof IContainer) {
						return entry;
					}
				} else if (target instanceof java.io.File){
					java.io.File file = JavaModel.getFile(target);
					if (file != null) {
						if (org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(file.getName())){
							return entry;
						}
					} else {
						// external directory
						return entry;
					}
				}
			}
		} catch(JavaModelException e){

				entry = jProject.getClasspathEntryFor(rootPath);
				if (entry != null){
					Object target = JavaModel.getTarget(entry.getSourceAttachmentPath(), true);
					if (target != null) {
						return entry;
							IFile file = (IFile) target;
							if (org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(file.getName())){
								return entry;
							}
						} else if (target instanceof IContainer) {
							return entry;
						}
					} else if (target instanceof java.io.File){
						java.io.File file = (java.io.File) target;
						if (org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(file.getName())){
							return entry;
						}
					}
				}
			} catch(JavaModelException e){



public IResource resource() {
	if (this.resource != null) // perf improvement to avoid message send in resource()
		return this.resource;
	return super.resource();
}
/*
 * @see IJavaElement
 */
public IResource resource(PackageFragmentRoot root) {
	return this.resource;
}

/**

protected void toStringInfo(int tab, StringBuffer buffer, Object info, boolean showResolvedInfo) {
	buffer.append(this.tabString(tab));
	IPath path = getPath();
	if (isExternal()) {
		buffer.append(path.toOSString());
	} else if (getJavaProject().getElementName().equals(path.segment(0))) {
	    if (path.segmentCount() == 1) {
			buffer.append("<project root>"); //$NON-NLS-1$
	    } else {
			buffer.append(path.removeFirstSegments(1).makeRelative());
	    }
	} else {
		buffer.append(path);
			buffer.append(path.toOSString());
	    } else {
			buffer.append(path);
	    }
	}
	if (info == null) {
		buffer.append(" (not open)"); //$NON-NLS-1$

Lines 134-140 Link Here

(-)model/org/eclipse/jdt/internal/core/JavaProjectElementInfo.java (-1 / +1 lines)
134	String resName = res.getName();	134	String resName = res.getName();
135		135
136	// ignore a jar file on the classpath	136	// ignore a jar file on the classpath
137	if (isClasspathResolved && org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(resName) && this.isClasspathEntryOrOutputLocation(resFullPath, classpath, projectOutput)) {	137	if (isClasspathResolved && isClasspathEntryOrOutputLocation(resFullPath, classpath, projectOutput)) {
138	break;	138	break;
139	}	139	}
140	// ignore .java file if src == project	140	// ignore .java file if src == project




	 * @param accumulatedRoots ObjectVector
	 * @param rootIDs HashSet
	 * @param referringEntry the CP entry (project) referring to this entry, or null if initial project
	 * @param checkExistency boolean
	 * @param retrieveExportedRoots boolean
	 * @throws JavaModelException
	 */

		ObjectVector accumulatedRoots, 
		HashSet rootIDs, 
		IClasspathEntry referringEntry,
		boolean checkExistency,
		boolean retrieveExportedRoots,
		Map rootToResolvedEntries) throws JavaModelException {
			

			case IClasspathEntry.CPE_SOURCE :

				if (projectPath.isPrefixOf(entryPath)){
					Object target = JavaModel.getTarget(entryPath, true/*check existency*/);
					if (target == null) return;

					if (target instanceof IFolder || target instanceof IProject){
						root = getPackageFragmentRoot((IResource)target);
							root = getPackageFragmentRoot((IResource)target);
						}
					} else {
						root = getFolderPackageFragmentRoot(entryPath);
					}
				}
				break;

			// internal/external JAR or folder
			case IClasspathEntry.CPE_LIBRARY :
				if (referringEntry != null  && !resolvedEntry.isExported()) 
					return;
				Object target = JavaModel.getTarget(entryPath, true/*check existency*/);
				if (target == null) 
					return;

				if (target instanceof IResource){
					// internal target
					root = getPackageFragmentRoot((IResource) target, entryPath);
				} else if (target instanceof File) {
					// external target
					if (JavaModel.isFile(target)) {
						root = new JarPackageFragmentRoot(entryPath, this);
					} else if (((File) target).isDirectory()) {
						root = new ExternalPackageFragmentRoot(entryPath, this);
							root = new ExternalPackageFragmentRoot(entryPath, this);
						}
					}
				} else {
					root = getPackageFragmentRoot(entryPath);
				}
				break;


							accumulatedRoots, 
							rootIDs, 
							rootToResolvedEntries == null ? resolvedEntry : ((ClasspathEntry)resolvedEntry).combineWith((ClasspathEntry) referringEntry), // only combine if need to build the reverse map 
							checkExistency, 
							retrieveExportedRoots,
							rootToResolvedEntries);
					}

			accumulatedRoots, 
			new HashSet(5), // rootIDs
			null, // inside original project
			true, // check existency
			retrieveExportedRoots,
			rootToResolvedEntries);
		IPackageFragmentRoot[] rootArray = new IPackageFragmentRoot[accumulatedRoots.size()];

	 * @param accumulatedRoots ObjectVector
	 * @param rootIDs HashSet
	 * @param referringEntry project entry referring to this CP or null if initial project
	 * @param checkExistency boolean
	 * @param retrieveExportedRoots boolean
	 * @throws JavaModelException
	 */

		ObjectVector accumulatedRoots, 
		HashSet rootIDs, 
		IClasspathEntry referringEntry,
		boolean checkExistency,
		boolean retrieveExportedRoots,
		Map rootToResolvedEntries) throws JavaModelException {


				accumulatedRoots,
				rootIDs,
				referringEntry,
				checkExistency,
				retrieveExportedRoots,
				rootToResolvedEntries);
		}

			path = getPath().append(path);
		}
		int segmentCount = path.segmentCount();
		if (segmentCount == 0) {
			return null;
		}
		if (path.getDevice() != null || JavaModel.getExternalTarget(path, true/*check existence*/) != null) {
			// external path
			return getPackageFragmentRoot0(path);
		}
		IWorkspaceRoot workspaceRoot = this.project.getWorkspace().getRoot();
		if (segmentCount == 1) {
			String projectName = path.segment(0);
			if (getElementName().equals(projectName)) { // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=75814
				// default root
				return getPackageFragmentRoot(this.project);
			} else {
				// lib being another project
				return getPackageFragmentRoot(workspaceRoot.getProject(projectName));
			}
		}
		IResource resource = workspaceRoot.findMember(path); 
		if (resource == null) {
			// resource doesn't exist in workspace
			if (path.getFileExtension() != null) {
				// assume it is a file
				resource = workspaceRoot.getFile(path);
			} else {
				// assume it is a folder
				resource = workspaceRoot.getFolder(path);
			}
		}
		return getPackageFragmentRoot(resource);
	}

	/**

	private IPackageFragmentRoot getPackageFragmentRoot(IResource resource, IPath entryPath) {
		switch (resource.getType()) {
			case IResource.FILE:
				return new JarPackageFragmentRoot(resource, this);
					return new JarPackageFragmentRoot(resource, this);
				} else {
					return null;
				}
			case IResource.FOLDER:
				if (ExternalFoldersManager.isInternalPathForExternalFolder(resource.getFullPath()))
					return new ExternalPackageFragmentRoot(resource, entryPath, this);

	 * @see IJavaProject
	 */
	public IPackageFragmentRoot getPackageFragmentRoot(String libraryPath) {

		return getPackageFragmentRoot0(JavaProject.canonicalizedPath(new Path(libraryPath)));
	}


	 * no path canonicalization
	 */
	public IPackageFragmentRoot getPackageFragmentRoot0(IPath libraryPath) {
		IFolder linkedFolder = JavaModelManager.getExternalManager().getFolder(libraryPath);
		if (linkedFolder != null)
			return new ExternalPackageFragmentRoot(linkedFolder, libraryPath, this);
		return new JarPackageFragmentRoot(libraryPath, this);
		
	}

	/**




import java.util.HashSet;
import java.util.Map;

import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;

					break;

				case IClasspathEntry.CPE_LIBRARY:
					Object target = JavaModel.getTarget(path, false/*don't check resource existence*/);
					hasLibFolder |= target instanceof IContainer;
					if ((index = Util.indexOfMatchingPath(path, outputLocations, outputCount)) != -1){
						allowNestingInOutputLocations[index] = true;
					}


			// allow nesting source entries in each other as long as the outer entry excludes the inner one
			if (kind == IClasspathEntry.CPE_SOURCE
					|| (kind == IClasspathEntry.CPE_LIBRARY && (JavaModel.getTarget(entryPath, false/*don't check existence*/) instanceof IContainer))) {
				for (int j = 0; j < classpath.length; j++){
					IClasspathEntry otherEntry = classpath[j];
					if (otherEntry == null) continue;

					if (entry != otherEntry
						&& (otherKind == IClasspathEntry.CPE_SOURCE
								|| (otherKind == IClasspathEntry.CPE_LIBRARY
										&& (JavaModel.getTarget(otherPath, false/*don't check existence*/) instanceof IContainer)))) {
						char[][] inclusionPatterns, exclusionPatterns;
						if (otherPath.isPrefixOf(entryPath)
								&& !otherPath.equals(entryPath)

						IResource resolvedResource = (IResource) target;
						switch(resolvedResource.getType()){
							case IResource.FILE :
								if (checkSourceAttachment
									&& sourceAttachment != null
									&& !sourceAttachment.isEmpty()
									&& JavaModel.getTarget(sourceAttachment, true) == null){
									return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Messages.bind(Messages.classpath_unboundSourceAttachment, new String [] {sourceAttachment.toString(), path.toString(), projectName}));
										return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Messages.bind(Messages.classpath_unboundSourceAttachment, new String [] {sourceAttachment.toString(), path.toString(), projectName}));
									}
								} else {
									return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Messages.bind(Messages.classpath_illegalLibraryArchive, new String[] {entryPathMsg, projectName}));
								}
								break;
							case IResource.FOLDER :	// internal binary folder

						File file = JavaModel.getFile(target);
					    if (file == null) {
							return  new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Messages.bind(Messages.classpath_illegalExternalFolder, new String[] {path.toOSString(), projectName}));
					    } else if (!org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(file.getName())) {
							return  new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Messages.bind(Messages.classpath_illegalLibraryArchive, (new String[] {path.toOSString(), projectName})));
					    } else if (checkSourceAttachment
								&& sourceAttachment != null
								&& !sourceAttachment.isEmpty()





import java.util.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipException;
import java.util.zip.ZipFile;

import org.eclipse.core.resources.IResource;

		IJavaElement[] children;
		ZipFile jar = null;
		try {
			// always create the default package
			rawPackageInfo.put(CharOperation.NO_STRINGS, new ArrayList[] { EMPTY_LIST, EMPTY_LIST });
	
			IJavaProject project = getJavaProject();
			String sourceLevel = project.getOption(JavaCore.COMPILER_SOURCE, true);
			String compliance = project.getOption(JavaCore.COMPILER_COMPLIANCE, true);
			jar = getJar();

			// always create the default package
			rawPackageInfo.put(CharOperation.NO_STRINGS, new ArrayList[] { EMPTY_LIST, EMPTY_LIST });
			
			for (Enumeration e= jar.entries(); e.hasMoreElements();) {
				ZipEntry member= (ZipEntry) e.nextElement();
				initRawPackageInfo(rawPackageInfo, member.getName(), member.isDirectory(), sourceLevel, compliance);
			}
			
			// loop through all of referenced packages, creating package fragments if necessary
			// and cache the entry names in the rawPackageInfo table
			children = new IJavaElement[rawPackageInfo.size()];
			int index = 0;

				children[index++] = getPackageFragment(pkgName);
			}
		} catch (CoreException e) {
			if (e.getCause() instanceof ZipException) {
				// not a ZIP archive, leave the children empty
				Util.log(e, "Invalid ZIP archive: " + toStringWithAncestors()); //$NON-NLS-1$
				children = NO_ELEMENTS;
			} else if (e instanceof JavaModelException) {
				throw (JavaModelException)e;
			} else {
				throw new JavaModelException(e);
			}
		} finally {
			JavaModelManager.getJavaModelManager().closeZipFile(jar);
		}

		}
	}	
	public IResource resource(PackageFragmentRoot root) {
		if (this.resource == null) {
			this.resource = JavaModel.getTarget(this.jarPath, false);
		}
		if (this.resource instanceof IResource) {
			return super.resource(root);
		} else {
			// external jar
			return null;
		}
		return super.resource(root);
	}



	}

	/**
	 * Returns whether the corresponding resource or associated file exists
	 */
	protected boolean resourceExists(IResource underlyingResource) {
		if (underlyingResource == null) {
			return 
				JavaModel.getExternalTarget(
					getPath()/*don't make the path relative as this is an external archive*/, 
					true/*check existence*/) != null;	
		} else {
			return super.resourceExists(underlyingResource);
		}
	}
	
	protected void toStringAncestors(StringBuffer buffer) {
		if (isExternal())
			// don't show project as it is irrelevant for external jar files.
			// also see https://bugs.eclipse.org/bugs/show_bug.cgi?id=146615
			return;
		super.toStringAncestors(buffer);
	}
}
protected void toStringAncestors(StringBuffer buffer) {
	if (isExternal())
		// don't show project as it is irrelevant for external jar files.
		// also see https://bugs.eclipse.org/bugs/show_bug.cgi?id=146615
		return;
	super.toStringAncestors(buffer);
}
}




	 *	<li>a project - the element returned is the corresponding <code>IJavaProject</code></li>
	 *	<li>a <code>.java</code> file - the element returned is the corresponding <code>ICompilationUnit</code></li>
	 *	<li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li>
	 *	<li>a ZIP archive (e.g. a <code>.jar</code>, a <code>.zip</code> file, etc.) - the element returned is the corresponding <code>IPackageFragmentRoot</code></li>
	 *  <li>a folder - the element returned is the corresponding <code>IPackageFragmentRoot</code>
	 *			or <code>IPackageFragment</code></li>
	 *  <li>the workspace root resource - the element returned is the <code>IJavaModel</code></li>

	 * <p>The file must be one of:<ul>
	 *	<li>a <code>.java</code> file - the element returned is the corresponding <code>ICompilationUnit</code></li>
	 *	<li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li>
	 *	<li>a ZIP archive (e.g. a <code>.jar</code>, a <code>.zip</code> file, etc.) - the element returned is the corresponding <code>IPackageFragmentRoot</code></li>
	 *	</ul>
	 * <p>
	 * Creating a Java element has the side effect of creating and opening all of the

				return createCompilationUnitFrom(file, project);
			if (org.eclipse.jdt.internal.compiler.util.Util.isClassFileName(name))
				return createClassFileFrom(file, project);
			return createJarPackageFragmentRootFrom(file, project);
				return createJarPackageFragmentRootFrom(file, project);
		}
		return null;
	}

Lines 77-83 Link Here

(-)model/org/eclipse/jdt/internal/core/PackageFragmentRootInfo.java (-1 / +1 lines)
77	if (Util.isValidClassFileName(fileName, sourceLevel, complianceLevel))	77	if (Util.isValidClassFileName(fileName, sourceLevel, complianceLevel))
78	continue nextResource;	78	continue nextResource;
79	// ignore .zip or .jar file on classpath	79	// ignore .zip or .jar file on classpath
80	if (org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(fileName) && isClasspathEntry(member.getFullPath(), classpath))	80	if (isClasspathEntry(member.getFullPath(), classpath))
81	continue nextResource;	81	continue nextResource;
82	break;	82	break;
83		83

Lines 324-330 Link Here

(-)model/org/eclipse/jdt/internal/core/ClasspathChange.java (-1 lines)
324	accumulatedRoots,	324	accumulatedRoots,
325	rootIDs,	325	rootIDs,
326	null, // inside original project	326	null, // inside original project
327	true, // check existency
328	false, // don't retrieve exported roots	327	false, // don't retrieve exported roots
329	null); /no reverse map/	328	null); /no reverse map/
330	pkgFragmentRoots = new PackageFragmentRoot[accumulatedRoots.size()];	329	pkgFragmentRoots = new PackageFragmentRoot[accumulatedRoots.size()];

Lines 164-172 Link Here

(-)batch/org/eclipse/jdt/internal/compiler/batch/FileSystem.java (-3 / +1 lines)
164	convertPathSeparators(destinationPath));	164	convertPathSeparators(destinationPath));
165	}	165	}
166	} else {	166	} else {
167	String lowercaseClasspathName = classpathName.toLowerCase();	167	if (Util.isPotentialZipArchive(classpathName)) {
168	if (lowercaseClasspathName.endsWith(SUFFIX_STRING_jar)
169	\|\| lowercaseClasspathName.endsWith(SUFFIX_STRING_zip)) {
170	if (isSourceOnly) {	168	if (isSourceOnly) {
171	// source only mode	169	// source only mode
172	result = new ClasspathSourceJar(file, true, accessRuleSet,	170	result = new ClasspathSourceJar(file, true, accessRuleSet,




						File f = new File(classpath);
						String id = null;
						if (f.isFile()) {
							if (Util.isPotentialZipArchive(classpath)) {
								id = Logger.CLASSPATH_JAR;
							} else {
								id = Logger.CLASSPATH_FILE;

public static File[][] getLibrariesFiles(File[] files) {
	FilenameFilter filter = new FilenameFilter() {
		public boolean accept(File dir, String name) {
			return Util.isPotentialZipArchive(name);
			if (lowerCaseName.endsWith(SuffixConstants.SUFFIX_STRING_jar) || lowerCaseName.endsWith(SuffixConstants.SUFFIX_STRING_zip)) {
				return true;
			}
			return false;
		}
	};
	final int filesLength = files.length;

		destPath = NONE; // keep == comparison valid
	}
	if (rejectDestinationPathOnJars && destPath != null &&
			Util.isPotentialZipArchive(currentClasspathName)) {
				currentClasspathName.endsWith(".zip"))) { //$NON-NLS-1$
		throw new InvalidInputException(
			this.bind("configure.unexpectedDestinationPathEntryFile", //$NON-NLS-1$
						currentClasspathName));




\ with ''+''.\n\
\ \n\
\ Classpath options:\n\
\    -cp -classpath <directories and ZIP archives separated by {0}>\n\
\                       specify location for application classes and sources.\n\
\                       Each directory or file can specify access rules for\n\
\                       types between ''['' and '']'' (e.g. [-X] to forbid\n\
\                       access to type X, [~X] to discourage access to type X,\n\
\                       [+p/X{0}-p/*] to forbid access to all types in package p\n\
\                       but allow access to p/X)\n\
\    -bootclasspath <directories and ZIP archives separated by {0}>\n\
\                       specify location for system classes. Each directory or\n\
\                       file can specify access rules for types between ''[''\n\
\                       and '']''\n\
\    -sourcepath <directories and ZIP archives separated by {0}>\n\
\                       specify location for application sources. Each directory\n\
\                       or file can specify access rules for types between ''[''\n\
\                       and '']''. Each directory can further specify a specific\n\

\                       and '']''; this overrides the general ''-d'' option.\n\
\                       .class files created from source files contained in a\n\
\                       jar file are put in the user.dir folder in case no\n\
\                       general ''-d'' option is specified. ZIP archives cannot\n\
\                       override the general ''-d'' option\n\
\    -extdirs <directories separated by {0}>\n\
\                       specify location for extension ZIP archives\n\
\    -endorseddirs <directories separated by {0}>\n\
\                       specify location for endorsed ZIP archives\n\
\    -d <dir>           destination directory (if omitted, no directory is\n\
\                       created); this option can be overridden per source\n\
\                       directory\n\

\ Annotation processing options:\n\
\   These options are meaningful only in a 1.6 environment.\n\
\    -Akey[=value]        options that are passed to annotation processors\n\
\    -processorpath <directories and ZIP archives separated by {0}>\n\
\                         specify locations where to find annotation processors.\n\
\                         If this option is not used, the classpath will be\n\
\                         searched for processors\n\




	public final static char[] SUFFIX_CLASS = SUFFIX_STRING_CLASS.toCharArray();
	public final static char[] SUFFIX_java = SUFFIX_STRING_java.toCharArray();
	public final static char[] SUFFIX_JAVA = SUFFIX_STRING_JAVA.toCharArray();
	
	public final static String EXTENSION_jar = "jar"; //$NON-NLS-1$
	public final static String EXTENSION_JAR = "JAR"; //$NON-NLS-1$
	public final static String EXTENSION_zip = "zip"; //$NON-NLS-1$
	public final static String EXTENSION_ZIP = "ZIP"; //$NON-NLS-1$

	public final static String SUFFIX_STRING_jar = "." + EXTENSION_jar; //$NON-NLS-1$
	public final static String SUFFIX_STRING_JAR = "." + EXTENSION_JAR; //$NON-NLS-1$
	public final static String SUFFIX_STRING_zip = "." + EXTENSION_zip; //$NON-NLS-1$
	public final static String SUFFIX_STRING_ZIP = "." + EXTENSION_ZIP; //$NON-NLS-1$

	public final static char[] SUFFIX_jar = SUFFIX_STRING_jar.toCharArray();
	public final static char[] SUFFIX_JAR = SUFFIX_STRING_JAR.toCharArray();
	public final static char[] SUFFIX_zip = SUFFIX_STRING_zip.toCharArray(); 
	public final static char[] SUFFIX_ZIP = SUFFIX_STRING_ZIP.toCharArray();
}




			}
		}
	}	

	/**
	 * Returns whether the given name is potentially a zip archive file name
	 * (it has a file extension and it is not ".java" nor ".class")
	 */
	public final static boolean isPotentialZipArchive(String name) {
		int lastDot = name.lastIndexOf('.');
		if (lastDot == -1)
			return false; // no file extension, it cannot be a zip archive name
		if (name.lastIndexOf(File.separatorChar) > lastDot)
			return false; // dot was before the last file separator, it cannot be a zip archive name
		int length = name.length();
		int extensionLength = length - lastDot - 1;
		if (extensionLength == EXTENSION_java.length()) {
			for (int i = extensionLength-1; i >=0; i--) {
				if (Character.toLowerCase(name.charAt(length - extensionLength + i)) != EXTENSION_java.charAt(i)) {
					break; // not a ".java" file, check ".class" file case below
				}
				if (i == 0) {
					return false; // it is a ".java" file, it cannot be a zip archive name
					c = name.charAt(nameLength - j - 1);
					suffixIndex = suffixLength - j - 1;
					if (c != SUFFIX_zip[suffixIndex] && c != SUFFIX_ZIP[suffixIndex]) return false;
				}
				return true;
			}
		}
		if (extensionLength == EXTENSION_class.length()) {
			for (int i = extensionLength-1; i >=0; i--) {
				if (Character.toLowerCase(name.charAt(length - extensionLength + i)) != EXTENSION_class.charAt(i)) {
					return true; // not a ".class" file, so this is a potential archive name
				}
			}
			return false; // it is a ".class" file, it cannot be a zip archive name
		}
		return true; // it is neither a ".java" file nor a ".class" file, so this is a potential archive name
	}

	/**
	 * Returns true iff str.toLowerCase().endsWith(".class")
	 * implementation is not creating extra strings.

Lines 13-18 Link Here

(-)antadapter/org/eclipse/jdt/core/CheckDebugAttributes.java (-7 / +11 lines)
13	import java.io.IOException;	13	import java.io.IOException;
14	import java.util.Enumeration;	14	import java.util.Enumeration;
15	import java.util.zip.ZipEntry;	15	import java.util.zip.ZipEntry;
		16	import java.util.zip.ZipException;
16	import java.util.zip.ZipFile;	17	import java.util.zip.ZipFile;
17		18
18	import org.apache.tools.ant.BuildException;	19	import org.apache.tools.ant.BuildException;
Lines 50-57 Link Here
50	}	51	}
51	try {	52	try {
52	boolean hasDebugAttributes = false;	53	boolean hasDebugAttributes = false;
53	if (org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(this.file)) {	54	if (org.eclipse.jdt.internal.compiler.util.Util.isClassFileName(this.file)) {
54	ZipFile jarFile = new ZipFile(this.file);	55	IClassFileReader classFileReader = ToolFactory.createDefaultClassFileReader(this.file, IClassFileReader.ALL);
		56	hasDebugAttributes = checkClassFile(classFileReader);
		57	} else {
		58	ZipFile jarFile = null;
		59	try {
		60	jarFile = new ZipFile(this.file);
		61	} catch (ZipException e) {
		62	throw new BuildException(AntAdapterMessages.getString("checkDebugAttributes.file.argument.must.be.a.classfile.or.a.jarfile")); //$NON-NLS-1$
		63	}
55	for (Enumeration entries = jarFile.entries(); !hasDebugAttributes && entries.hasMoreElements(); ) {	64	for (Enumeration entries = jarFile.entries(); !hasDebugAttributes && entries.hasMoreElements(); ) {
56	ZipEntry entry = (ZipEntry) entries.nextElement();	65	ZipEntry entry = (ZipEntry) entries.nextElement();
57	if (org.eclipse.jdt.internal.compiler.util.Util.isClassFileName(entry.getName())) {	66	if (org.eclipse.jdt.internal.compiler.util.Util.isClassFileName(entry.getName())) {
Lines 59-69 Link Here
59	hasDebugAttributes = checkClassFile(classFileReader);	68	hasDebugAttributes = checkClassFile(classFileReader);
60	}	69	}
61	}	70	}
62	} else if (org.eclipse.jdt.internal.compiler.util.Util.isClassFileName(this.file)) {
63	IClassFileReader classFileReader = ToolFactory.createDefaultClassFileReader(this.file, IClassFileReader.ALL);
64	hasDebugAttributes = checkClassFile(classFileReader);
65	} else {
66	throw new BuildException(AntAdapterMessages.getString("checkDebugAttributes.file.argument.must.be.a.classfile.or.a.jarfile")); //$NON-NLS-1$
67	}	71	}
68	if (hasDebugAttributes) {	72	if (hasDebugAttributes) {
69	getProject().setUserProperty(this.property, "has debug"); //$NON-NLS-1$	73	getProject().setUserProperty(this.property, "has debug"); //$NON-NLS-1$




					IResource resource = (IResource) target;
					ClasspathLocation bLocation = null;
					if (resource instanceof IFile) {
						if (!(org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(path.lastSegment())))
							continue nextEntry;
						AccessRuleSet accessRuleSet = 
							(JavaCore.IGNORE.equals(javaProject.getOption(JavaCore.COMPILER_PB_FORBIDDEN_REFERENCE, true))
							&& JavaCore.IGNORE.equals(javaProject.getOption(JavaCore.COMPILER_PB_DISCOURAGED_REFERENCE, true)))

						binaryLocationsPerProject.put(p, existingLocations);
					}
				} else if (target instanceof File) {
					if (!(org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(path.lastSegment())))
						continue nextEntry;
					AccessRuleSet accessRuleSet = 
						(JavaCore.IGNORE.equals(javaProject.getOption(JavaCore.COMPILER_PB_FORBIDDEN_REFERENCE, true))
							&& JavaCore.IGNORE.equals(javaProject.getOption(JavaCore.COMPILER_PB_DISCOURAGED_REFERENCE, true)))

Lines 362-368 Link Here

(-)Eclipse Java Tests Model/src/org/eclipse/jdt/tests/core/JarTests.java (-1 / +1 lines)
362		362
363		363
364	IPackageFragmentRoot wrongRoot = jProject1.getPackageFragmentRoot(jarPath);	364	IPackageFragmentRoot wrongRoot = jProject1.getPackageFragmentRoot(jarPath);
365	IPackageFragmentRoot rightRoot = jProject2.getPackageFragmentRoot(jarPath);	365	IPackageFragmentRoot rightRoot = jProject2.getPackageFragmentRoot(workspaceRoot.getFile(new Path(jarPath)));
366		366
367	assertTrue("Wrong PackageFragmentRoot exists", !wrongRoot.exists());	367	assertTrue("Wrong PackageFragmentRoot exists", !wrongRoot.exists());
368	assertTrue("Right PackageFragmentRoot does not exists", rightRoot.exists());	368	assertTrue("Right PackageFragmentRoot does not exists", rightRoot.exists());




		ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P3", "/P1"}) {
	        public void initialize(IPath containerPath, IJavaProject project) throws CoreException {
	            super.initialize(containerPath, project);
	            refreshExternalArchives(p1);
	        }
		});
		getWorkspace().run(new IWorkspaceRunnable() {

	try {
		createProject("P1");
		createExternalFolder("externalLib");
		ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", getExternalResourcePath("externalLib")}));
		IJavaProject p2 = createJavaProject(
				"P2", 
				new String[] {}, 
				new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"}, 
				"");
		IPackageFragmentRoot root = p2.getPackageFragmentRoot(getExternalResourcePath("externalLib"));
		assertTrue(getExternalResourcePath("externalLib") + " should exist", root.exists());
	} finally {
		stopDeltas();
		deleteExternalResource("externalLib");
		deleteProject("P1");
		deleteProject("P2");
	}
}

public void testContainerInitializer22() throws CoreException {
	try {
		createProject("P1");
		createExternalFile("externalLib.abc", "");
		ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", getExternalResourcePath("externalLib.abc")}));
		IJavaProject p2 = createJavaProject(
				"P2", 
				new String[] {}, 
				new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"}, 
				"");
		IPackageFragmentRoot root = p2.getPackageFragmentRoot(getExternalResourcePath("externalLib.abc"));
		assertTrue(getExternalResourcePath("externalLib.abc") + " should exist", root.exists());
	} finally {
		stopDeltas();
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P2");
		deleteProject("P1");
		deleteProject("P2");
	}
}

public void testContainerInitializer23() throws CoreException {
	try {
		createProject("P1");
		IFile lib = createFile("/P1/internalLib.abc", "");
		ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", "/P1/internalLib.abc"}));
		IJavaProject p2 = createJavaProject(
				"P2", 
				new String[] {}, 
				new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"}, 
				"");
		IPackageFragmentRoot root = p2.getPackageFragmentRoot(lib);
		assertTrue("/P1/internalLib.abc should exist", root.exists());
	} finally {
		stopDeltas();
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P2");
		deleteProject("P1");
		deleteProject("P2");
	}




		);
	} finally {
		if(f != null) {
			deleteResource(f);
		}
		this.deleteProject("P");
		this.stopDeltas();

		);
	} finally {
		if(f != null) {
			deleteResource(f);
		}
		this.deleteProject("P");
		this.stopDeltas();

		);
	} finally {
		if(f != null) {
			deleteResource(f);
		}
		this.deleteProject("P");
		this.stopDeltas();

		);
	} finally {
		if(f != null) {
			deleteResource(f);
		}
		this.deleteProject("P");
		this.stopDeltas();

		);
	} finally {
		if(f != null) {
			deleteResource(f);
		}
		this.deleteProject("P");
		this.stopDeltas();

		);
	} finally {
		if(f != null) {
			deleteResource(f);
		}
		this.deleteProject("P");
		this.stopDeltas();

		);
	} finally {
		if(f != null) {
			deleteResource(f);
		}
		this.deleteProject("P");
		this.stopDeltas();

		);
	} finally {
		if(f != null) {
			deleteResource(f);
		}
		this.deleteProject("P");
		this.stopDeltas();

		);
	} finally {
		if(f != null) {
			deleteResource(f);
		}
		this.deleteProject("P");
		this.stopDeltas();

		);
	} finally {
		if(f != null) {
			deleteResource(f);
		}
		this.deleteProject("P");
		this.stopDeltas();

		waitUntilIndexesReady();
		startDeltas();
		
		deleteResource(f);
		getJavaModel().refreshExternalArchives(null,null);
		
		assertDeltas(

		);
	} finally {
		if(f != null) {
			deleteResource(f);
		}
		this.deleteProject("P");
		this.stopDeltas();

		waitUntilIndexesReady();
		startDeltas();
		
		deleteResource(f);
		getJavaModel().refreshExternalArchives(new IJavaElement[]{project},null);
		
		assertDeltas(

		);
	} finally {
		if(f != null) {
			deleteResource(f);
		}
		this.deleteProject("P");
		this.stopDeltas();

		waitUntilIndexesReady();
		startDeltas();
		
		deleteResource(f);
		IPackageFragmentRoot root = project.getPackageFragmentRoot(pPath);
		getJavaModel().refreshExternalArchives(new IJavaElement[]{root},null);
		

		);
	} finally {
		if(f != null) {
			deleteResource(f);
		}
		this.deleteProject("P");
		this.stopDeltas();

		);
	} finally {
		if(f != null) {
			deleteResource(f);
		}
		this.deleteProject("P");
		this.stopDeltas();




	try {
		IJavaProject p = createJavaProject("P");
		createExternalFolder("externalLib");
		setClasspath(p, new IClasspathEntry[] {JavaCore.newLibraryEntry(new Path(getExternalResourcePath("externalLib")), null, null)});
		assertElementDescendants(
			"Unexpected project content", 
			"P\n" + 

			p
		);
	} finally {
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

public void testAddExternalLibFolder2() throws CoreException {
	try {
		IJavaProject p = createJavaProject("P");
		IPath path = new Path(getExternalResourcePath("externalLib"));
		setClasspath(p, new IClasspathEntry[] {JavaCore.newLibraryEntry(path, null, null)});
		assertElementDescendants(
			"Unexpected project content", 

		IJavaProject p = createJavaProject("P");
		createExternalFolder("externalLib/p");
		createExternalFile("externalLib/p/X.class", "");
		setClasspath(p, new IClasspathEntry[] {JavaCore.newLibraryEntry(new Path(getExternalResourcePath("externalLib")), null, null)});
		assertElementDescendants(
			"Unexpected project content", 
			"P\n" + 

			p
		);
	} finally {
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

 */
public void testAddExternalLibFolder4() throws CoreException {
	try {
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		expandAll(p);
		createExternalFolder("externalLib");
		refresh(p);

			p
		);
	} finally {
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

		simulateExitRestart();
		createExternalFolder("externalLib/p");
		createExternalFile("externalLib/p/X.class", "");
		IJavaProject p = importJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		waitForAutoBuild(); // since the project is imported, the linked folder can only be created by auto-build
		assertElementDescendants(
			"Unexpected project content", 

			p
		);
	} finally {
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

/*
 * Ensures that adding a library entry for an existing empty external ZIP archive updates the model
 */
public void testAddZIPArchive1() throws Exception {
	try {
		IJavaProject p = createJavaProject("P");
		createExternalFile("externalLib.abc", "");
		setClasspath(p, new IClasspathEntry[] {JavaCore.newLibraryEntry(new Path(getExternalResourcePath("externalLib.abc")), null, null)});
		assertElementDescendants(
			"Unexpected project content", 
			"P\n" + 
			"  "+ getExternalPath() + "externalLib.abc",
			p
		);
	} finally {
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		deleteProject("P");
	}
}

/*
 * Ensures that adding a library entry for an non-existing external ZIP archive updates the model
 */
public void testAddZIPArchive2() throws CoreException {
	try {
		IJavaProject p = createJavaProject("P");
		IPath path = new Path(getExternalResourcePath("externalLib.abc"));
		setClasspath(p, new IClasspathEntry[] {JavaCore.newLibraryEntry(path, null, null)});
		assertElementDescendants(
			"Unexpected project content", 
			"P",
			p
		);
	} finally {
		deleteProject("P");
	}
}

/*
 * Ensures that adding a library entry for an existing non-empty external ZIP archive updates the model
 */
public void testAddZIPArchive3() throws CoreException, IOException {
	try {
		IJavaProject p = createJavaProject("P");
		org.eclipse.jdt.core.tests.util.Util.createJar(
			new String[] {
				"p/X.java",
				"package p;\n" +
				"public class X {\n" +
				"}"
			},
			getExternalResourcePath("externalLib.abc"), 
			"1.4");
		setClasspath(p, new IClasspathEntry[] {JavaCore.newLibraryEntry(new Path(getExternalResourcePath("externalLib.abc")), null, null)});
		assertElementDescendants(
			"Unexpected project content", 
			"P\n" + 
			"  "+ getExternalPath() + "externalLib.abc\n" + 
			"    <default> (...)\n" + 
			"    p (...)\n" + 
			"      X.class\n" + 
			"        class X\n" + 
			"          X()",
			p
		);
	} finally {
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		deleteProject("P");
	}
}

/*
 * Ensures that creating an external ZIP archive referenced by a library entry and refreshing updates the model
 */
public void testAddZIPArchive4() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		expandAll(p);
		createExternalFile("externalLib.abc", "");
		refreshExternalArchives(p);
		assertElementDescendants(
			"Unexpected project content", 
			"P\n" + 
			"  "+ getExternalPath() + "externalLib.abc",
			p
		);
	} finally {
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		deleteProject("P");
	}
}

/*
 * Ensures that importing a Java project with a library entry for an existing empty external ZIP archive after restart
 * updates the model
 */
public void testAddZIPArchive5() throws Exception {
	try {
		simulateExitRestart();
		org.eclipse.jdt.core.tests.util.Util.createJar(
			new String[] {
				"p/X.java",
				"package p;\n" +
				"public class X {\n" +
				"}"
			},
			getExternalResourcePath("externalLib.abc"), 
			"1.4");
		IJavaProject p = importJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		assertElementDescendants(
			"Unexpected project content", 
			"P\n" + 
			"  "+ getExternalPath() + "externalLib.abc\n" + 
			"    <default> (...)\n" + 
			"    p (...)\n" + 
			"      X.class\n" + 
			"        class X\n" + 
			"          X()",
			p
		);
	} finally {
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		deleteProject("P");
	}
}

/*
 * Ensures that adding a library entry for an existing empty internal ZIP archive updates the model
 */
public void testAddZIPArchive6() throws Exception {
	try {
		IJavaProject p = createJavaProject("P");
		createFile("/P/internalLib.abc", "");
		setClasspath(p, new IClasspathEntry[] {JavaCore.newLibraryEntry(new Path("/P/internalLib.abc"), null, null)});
		assertElementDescendants(
			"Unexpected project content", 
			"P\n" + 
			"  internalLib.abc",
			p
		);
	} finally {
		deleteProject("P");
	}
}

public void testChangeExternalLibFolder1() throws CoreException, IOException {
	try {
		createExternalFolder("externalLib");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "bin");
		expandAll(p);
		
		createExternalFolder("externalLib/p");

			p
		);
	} finally {
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

	try {
		createExternalFolder("externalLib/p");
		createExternalFile("externalLib/p/X.class", "");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "bin");
		expandAll(p);
		
		deleteExternalResource("externalLib/p");
		refresh(p);
		assertElementDescendants(
			"Unexpected project content", 

			p
		);
	} finally {
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

/*
 * Ensures that changing the content of an external ZIP archive and refreshing updates the model
 */
public void testChangeZIPArchive1() throws CoreException, IOException {
	try {
		createExternalFile("externalLib.abc", "");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "bin");
		expandAll(p);
		
		org.eclipse.jdt.core.tests.util.Util.createJar(
			new String[] {
				"p/X.java",
				"package p;\n" +
				"public class X {\n" +
				"}"
			},
			getExternalResourcePath("externalLib.abc"), 
			"1.4");
		refreshExternalArchives(p);
		assertElementDescendants(
			"Unexpected project content", 
			"P\n" + 
			"  "+ getExternalPath() + "externalLib.abc\n" + 
			"    <default> (...)\n" + 
			"    p (...)\n" + 
			"      X.class\n" + 
			"        class X\n" + 
			"          X()",
			p
		);
	} finally {
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		deleteProject("P");
	}
}

/*
 * Ensures that changing the content of an external ZIP archive and refreshing updates the model
 */
public void testChangeZIPArchive2() throws CoreException, IOException {
	try {
		org.eclipse.jdt.core.tests.util.Util.createJar(
			new String[] {
				"p/X.java",
				"package p;\n" +
				"public class X {\n" +
				"}"
			},
			getExternalResourcePath("externalLib.abc"), 
			"1.4");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "bin");
		expandAll(p);
		
		org.eclipse.jdt.core.tests.util.Util.createJar(
			new String[] {
				"p2/X.java",
				"package p2;\n" +
				"public class X {\n" +
				"}"
			},
			getExternalResourcePath("externalLib.abc"), 
			"1.4");
		refreshExternalArchives(p);
		assertElementDescendants(
			"Unexpected project content", 
			"P\n" + 
			"  "+ getExternalPath() + "externalLib.abc\n" + 
			"    <default> (...)\n" + 
			"    p2 (...)\n" + 
			"      X.class\n" + 
			"        class X\n" + 
			"          X()",
			p
		);
	} finally {
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		deleteProject("P");
	}
}

/*
 * Ensures that changing the content of an internal ZIP archive and refreshing updates the model
 */
public void testChangeZIPArchive3() throws CoreException, IOException {
	try {
		IJavaProject p = createJavaProject("P", new String[0], new String[] {"/P/internalLib.abc"}, "bin");
		IFile lib = createFile("/P/internalLib.abc", "");
		expandAll(p);
		
		org.eclipse.jdt.core.tests.util.Util.createJar(
			new String[] {
				"p/X.java",
				"package p;\n" +
				"public class X {\n" +
				"}"
			},
			lib.getLocation().toOSString(), 
			"1.4");
		p.getProject().refreshLocal(IResource.DEPTH_INFINITE, null);
		assertElementDescendants(
			"Unexpected project content", 
			"P\n" + 
			"  internalLib.abc\n" + 
			"    <default> (...)\n" + 
			"    p (...)\n" + 
			"      X.class\n" + 
			"        class X\n" + 
			"          X()",
			p
		);
	} finally {
		deleteProject("P");
	}
}

	try {
		createExternalFolder("externalLib/p/META-INF");
		createExternalFile("externalLib/p/test.txt", "test");
		createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		IPackageFragment pkg = getPackageFragmentRoot("P", getExternalResourcePath("externalLib")).getPackageFragment("p");
		Object[] resources = pkg.getNonJavaResources();
		assertResourceTreeEquals(
			"unexpected non java resources", 

			resources);
	} finally {
		deleteProject("P");
		deleteExternalResource("externalLib");
	}
}


	try {
		createExternalFolder("externalLib/META-INF");
		createExternalFile("externalLib/test.txt", "test");
		createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		IPackageFragmentRoot root = getPackageFragmentRoot("P", getExternalResourcePath("externalLib"));
		Object[] resources = root.getNonJavaResources();
		assertResourceTreeEquals(
			"unexpected non java resources", 

			resources);
	} finally {
		deleteProject("P");
		deleteExternalResource("externalLib");
	}
}
/**

public void testRemoveExternalLibFolder1() throws CoreException {
	try {
		createExternalFolder("externalLib");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		expandAll(p);
		setClasspath(p, new IClasspathEntry[] {});
		assertElementDescendants(

			p
		);
	} finally {
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

 */
public void testRemoveExternalLibFolder2() throws CoreException {
	try {
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		expandAll(p);
		setClasspath(p, new IClasspathEntry[] {});
		assertElementDescendants(

public void testRemoveExternalLibFolder3() throws CoreException {
	try {
		createExternalFolder("externalLib");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		expandAll(p);
		deleteExternalResource("externalLib");
		refresh(p);
		assertElementDescendants(
			"Unexpected project content", 

			p
		);
	} finally {
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

/*
 * Ensures that removing a library entry for an existing external ZIP archive updates the model
 */
public void testRemoveZIPArchive1() throws CoreException {
	try {
		createExternalFile("externalLib.abc", "");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		expandAll(p);
		setClasspath(p, new IClasspathEntry[] {});
		assertElementDescendants(
			"Unexpected project content", 
			"P",
			p
		);
	} finally {
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		deleteProject("P");
	}
}

/*
 * Ensures that removing a library entry for a non-existing external ZIP archive updates the model
 */
public void testRemoveZIPArchive2() throws CoreException {
	try {
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		expandAll(p);
		setClasspath(p, new IClasspathEntry[] {});
		assertElementDescendants(
			"Unexpected project content", 
			"P",
			p
		);
	} finally {
		deleteProject("P");
	}
}


/*
 * Ensures that removing an external ZIP archive referenced by a library entry and refreshing updates the model
 */
public void testRemoveZIPArchive3() throws CoreException {
	try {
		createExternalFile("externalLib.abc", "");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		expandAll(p);
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		assertElementDescendants(
			"Unexpected project content", 
			"P",
			p
		);
	} finally {
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		deleteProject("P");
	}
}

/*
 * Ensures that removing a library entry for an existing internal ZIP archive updates the model
 */
public void testRemoveZIPArchive4() throws CoreException {
	try {
		IJavaProject p = createJavaProject("P", new String[0], new String[] {"/P/internalLib.abc"}, "");
		createFile("/P/internalLib.abc", "");
		expandAll(p);
		setClasspath(p, new IClasspathEntry[] {});
		assertElementDescendants(
			"Unexpected project content", 
			"P",
			p
		);
	} finally {
		deleteProject("P");
	}
}

Lines 56-62 Link Here

(-)src/org/eclipse/jdt/core/tests/model/AttachSourceTests.java (-1 / +92 lines)
56	super(name);	56	super(name);
57	}	57	}
58	protected String getExternalFolder() {	58	protected String getExternalFolder() {
59	return getExternalFolderPath("externalFolder");	59	return getExternalResourcePath("externalFolder");
60	}	60	}
61	public ASTNode runConversion(IClassFile classFile, boolean resolveBindings) {	61	public ASTNode runConversion(IClassFile classFile, boolean resolveBindings) {
62	ASTParser parser = ASTParser.newParser(AST_INTERNAL_JLS2);	62	ASTParser parser = ASTParser.newParser(AST_INTERNAL_JLS2);
Lines 93-98 Link Here
93	};	93	};
94	org.eclipse.jdt.core.tests.util.Util.createClassFolder(pathsAndContents, externalFolder + "/lib", "1.4");	94	org.eclipse.jdt.core.tests.util.Util.createClassFolder(pathsAndContents, externalFolder + "/lib", "1.4");
95	org.eclipse.jdt.core.tests.util.Util.createSourceDir(pathsAndContents, externalFolder + "/src");	95	org.eclipse.jdt.core.tests.util.Util.createSourceDir(pathsAndContents, externalFolder + "/src");
		96
		97	org.eclipse.jdt.core.tests.util.Util.createJar(pathsAndContents, externalFolder + "/lib.abc", "1.4");
		98	org.eclipse.jdt.core.tests.util.Util.createSourceZip(pathsAndContents, externalFolder + "/src.abc");
96	}	99	}
97	private void setUpGenericJar() throws IOException, CoreException {	100	private void setUpGenericJar() throws IOException, CoreException {
98	String[] pathAndContents = new String[] {	101	String[] pathAndContents = new String[] {
Lines 407-412 Link Here
407	}	410	}
408	}	411	}
409	/*	412	/*
		413	* Ensures that one can attach an external ZIP archive containing sources to a library folder.
		414	*/
		415	public void testZIPArchive1() throws CoreException {
		416	try {
		417	IProject p = createProject("P1");
		418	IFolder lib = p.getFolder("lib");
		419	lib.createLink(new Path(getExternalFolder() + "/lib"), IResource.NONE, null);
		420	IJavaProject javaProject = createJavaProject("P2", new String[0], new String[] {"/P1/lib"}, "");
		421	IPackageFragmentRoot root = javaProject.getPackageFragmentRoot(lib);
		422	attachSource(root, getExternalFolder() + "/src.abc", "");
		423	IType type = root.getPackageFragment("p").getClassFile("X.class").getType();
		424	assertSourceEquals(
		425	"Unexpected source",
		426	"public class X {\n" +
		427	"}",
		428	type.getSource());
		429	} finally {
		430	deleteProject("P1");
		431	deleteProject("P2");
		432	}
		433	}
		434	/*
		435	* Ensures that one can attach a source folder to an external ZIP archive.
		436	*/
		437	public void testZIPArchive2() throws CoreException {
		438	try {
		439	IProject p = createProject("P1");
		440	IFolder src = p.getFolder("src");
		441	src.createLink(new Path(getExternalFolder() + "/src"), IResource.NONE, null);
		442	String externalLib = getExternalFolder() + "/lib.abc";
		443	IJavaProject javaProject = createJavaProject("P2", new String[0], new String[] {externalLib}, "");
		444	IPackageFragmentRoot root = javaProject.getPackageFragmentRoot(externalLib);
		445	attachSource(root, "/P1/src", "");
		446	IType type = root.getPackageFragment("p").getClassFile("X.class").getType();
		447	assertSourceEquals(
		448	"Unexpected source",
		449	"public class X {\n" +
		450	"}",
		451	type.getSource());
		452	} finally {
		453	deleteProject("P1");
		454	deleteProject("P2");
		455	}
		456	}
		457	/*
		458	* Ensures that one can attach an external ZIP archive containing sources to an external ZIP archive.
		459	*/
		460	public void testZIPArchive3() throws CoreException {
		461	try {
		462	String externalLib = getExternalFolder() + "/lib.abc";
		463	IJavaProject javaProject = createJavaProject("P", new String[0], new String[] {externalLib}, "");
		464	IPackageFragmentRoot root = javaProject.getPackageFragmentRoot(externalLib);
		465	attachSource(root, getExternalFolder() + "/src.abc", "");
		466	IType type = root.getPackageFragment("p").getClassFile("X.class").getType();
		467	assertSourceEquals(
		468	"Unexpected source",
		469	"public class X {\n" +
		470	"}",
		471	type.getSource());
		472	} finally {
		473	deleteProject("P");
		474	}
		475	}
		476	/*
477	* Ensures that one can attach an internal ZIP archive containing sources to an internal ZIP archive.
478	*/
479	public void testZIPArchive4() throws CoreException {
480	try {
481	IProject p = createProject("P1");
482	IFile lib = p.getFile("lib.abc");
483	lib.createLink(new Path(getExternalFolder() + "/lib.abc"), IResource.NONE, null);
484	IFile src = p.getFile("src.abc");
485	src.createLink(new Path(getExternalFolder() + "/src.abc"), IResource.NONE, null);
486	IJavaProject javaProject = createJavaProject("P2", new String[0], new String[] {"/P1/lib.abc"}, "");
487	IPackageFragmentRoot root = javaProject.getPackageFragmentRoot(lib);
488	attachSource(root, "/P1/src.abc", "");
489	IType type = root.getPackageFragment("p").getClassFile("X.class").getType();
490	assertSourceEquals(
491	"Unexpected source",
492	"public class X {\n" +
493	"}",
494	type.getSource());
495	} finally {
496	deleteProject("P1");
497	deleteProject("P2");
498	}
499	}
500	/*
410	* Ensures that the source of a generic method can be retrieved.	501	* Ensures that the source of a generic method can be retrieved.
411	*/	502	*/
412	public void testGeneric1() throws JavaModelException {	503	public void testGeneric1() throws JavaModelException {




				"}",
			},
			new HashMap(),
			getExternalResourcePath("externalLib"));
		createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		IClassFile classFile = getClassFile("P", getExternalResourcePath("externalLib"), "p", "X.class");
		ITypeHierarchy hierarchy = classFile.getType().newTypeHierarchy(null);
		assertHierarchyEquals(
			"Focus: X [in X.class [in p [in "+ getExternalPath() + "externalLib]]]\n" + 

			hierarchy);
	} finally {
		deleteProject("P");
		deleteExternalResource("externalLib");
	}
}
/*
 * Ensures that subtypes are found in an external ZIP archive
 */
public void testZIPArchive() throws CoreException, IOException {
	try {
		org.eclipse.jdt.core.tests.util.Util.createJar(
			new String[] {
				"p/X.java",
				"package p;\n" +
				"public class X {\n" +
				"}",
				"p/Y.java",
				"package p;\n" +
				"public class Y extends X {\n" +
				"}",
			},
			getExternalResourcePath("externalLib.abc"), 
			"1.4");
		createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		IClassFile classFile = getClassFile("P", getExternalResourcePath("externalLib.abc"), "p", "X.class");
		ITypeHierarchy hierarchy = classFile.getType().newTypeHierarchy(null);
		assertHierarchyEquals(
			"Focus: X [in X.class [in p [in "+ getExternalPath() + "externalLib.abc]]]\n" + 
			"Super types:\n" + 
			"Sub types:\n" + 
			"  Y [in Y.class [in p [in "+ getExternalPath() + "externalLib.abc]]]\n",
			hierarchy);
	} finally {
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		deleteProject("P");
	}
}
/*

Lines 2332-2338 Link Here

(-)src/org/eclipse/jdt/core/tests/model/CompletionTests2.java (-1 / +1 lines)
2332	requestor.getResults());	2332	requestor.getResults());
2333	} finally {	2333	} finally {
2334	removeClasspathEntry(this.currentProject, new Path(jarName));	2334	removeClasspathEntry(this.currentProject, new Path(jarName));
2335	deleteFile(new File(jarName));	2335	deleteResource(new File(jarName));
2336	}	2336	}
2337	}	2337	}
2338	}	2338	}




import org.eclipse.jdt.core.IClasspathContainer;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaElementDelta;
import org.eclipse.jdt.core.IJavaModelMarker;
import org.eclipse.jdt.core.IJavaModelStatus;

	try {
		IJavaProject p = createJavaProject("P");
		createExternalFolder("externalLib");
		setClasspath(p, new IClasspathEntry[] {JavaCore.newLibraryEntry(new Path(getExternalResourcePath("externalLib")), null, null)});
		assertMarkers("Unexpected markers", "", p);
	} finally {
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

public void testAddExternalLibFolder2() throws CoreException {
	try {
		createExternalFolder("externalLib");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		assertMarkers("Unexpected markers", "", p);
	} finally {
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

	try {
		waitForAutoBuild();
		IJavaProject p = createJavaProject("P");
		IPath path = new Path(getExternalResourcePath("externalLib"));
		setClasspath(p, new IClasspathEntry[] {JavaCore.newLibraryEntry(path, null, null)});
		assertMarkers(
			"Unexpected markers", 

public void testAddExternalLibFolder4() throws CoreException {
	try {
		waitForAutoBuild();
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		assertMarkers(
			"Unexpected markers", 
			"Project \'P\' is missing required library: \'"+ getExternalPath() + "externalLib\'",

 */
public void testAddExternalLibFolder5() throws CoreException {
	try {
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		waitForAutoBuild();
		createExternalFolder("externalLib");
		refresh(p);
		assertMarkers("Unexpected markers", "", p);
	} finally {
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

public void testAddExternalLibFolder6() throws CoreException {
	try {
		simulateExitRestart();
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		waitForAutoBuild();
		createExternalFolder("externalLib");
		refresh(p);
		assertMarkers("Unexpected markers", "", p);
	} finally {
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

/*
 * Ensures that adding a library entry for an existing external ZIP archive doesn't generate a marker
 */
public void testAddZIPArchive1() throws CoreException {
	try {
		IJavaProject p = createJavaProject("P");
		createExternalFile("externalLib.abc", "");
		setClasspath(p, new IClasspathEntry[] {JavaCore.newLibraryEntry(new Path(getExternalResourcePath("externalLib.abc")), null, null)});
		assertMarkers("Unexpected markers", "", p);
	} finally {
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		deleteProject("P");
	}
}

/*
 * Ensures that creating a project with a library entry for an existing external ZIP archive doesn't generate a marker
 */
public void testAddZIPArchive2() throws CoreException {
	try {
		createExternalFile("externalLib.abc", "");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		assertMarkers("Unexpected markers", "", p);
	} finally {
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		deleteProject("P");
	}
}

/*
 * Ensures that adding a library entry for a non-existing external ZIP archive generates a marker
 */
public void testAddZIPArchive3() throws CoreException {
	try {
		waitForAutoBuild();
		IJavaProject p = createJavaProject("P");
		IPath path = new Path(getExternalResourcePath("externalLib.abc"));
		setClasspath(p, new IClasspathEntry[] {JavaCore.newLibraryEntry(path, null, null)});
		assertMarkers(
			"Unexpected markers", 
			"Project \'P\' is missing required library: \'"+ getExternalPath() + "externalLib.abc\'",
			p);
	} finally {
		deleteProject("P");
	}
}

/*
 * Ensures that creating a project with a library entry for a non-existing external ZIP archive generates a marker
 */
public void testAddZIPArchive4() throws CoreException {
	try {
		waitForAutoBuild();
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		assertMarkers(
			"Unexpected markers", 
			"Project \'P\' is missing required library: \'"+ getExternalPath() + "externalLib.abc\'",
			p);
	} finally {
		deleteProject("P");
	}
}

/*
 * Ensures that creating an external ZIP archive referenced by a library entry and refreshing removes the marker
 */
public void testAddZIPArchive5() throws CoreException {
	try {
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		waitForAutoBuild();
		createExternalFile("externalLib.abc", "");
		refreshExternalArchives(p);
		assertMarkers("Unexpected markers", "", p);
	} finally {
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		deleteProject("P");
	}
}

/*
 * Ensures that creating an external ZIP archive referenced by a library entry and refreshing after a restart
 * removes the marker
 */
public void testAddZIPArchive6() throws CoreException {
	try {
		simulateExitRestart();
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		waitForAutoBuild();
		createExternalFile("externalLib.abc", "");
		refreshExternalArchives(p);
		assertMarkers("Unexpected markers", "", p);
	} finally {
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		deleteProject("P");
	}
}

/*
 * Ensures that adding a library entry for an existing internal ZIP archive doesn't generate a marker
 */
public void testAddZIPArchive7() throws CoreException {
	try {
		IJavaProject p = createJavaProject("P");
		createFile("/P/internalLib.abc", "");
		setClasspath(p, new IClasspathEntry[] {JavaCore.newLibraryEntry(new Path("/P/internalLib.abc"), null, null)});
		assertMarkers("Unexpected markers", "", p);
	} finally {
		deleteProject("P");
	}
}

 * (regression test for https://bugs.eclipse.org/bugs/show_bug.cgi?id=220542 )
 */
public void testExternalize2() throws CoreException {
	String externalLibPath = getExternalResourcePath("externalLib") + File.separator;
	IClasspathEntry entry = JavaCore.newLibraryEntry(new Path(externalLibPath), null, null);
	assertEquals("Unexpected external path", externalLibPath, entry.getPath().toOSString());
}

		IClasspathEntry[] newCP = new IClasspathEntry[originalCP.length+1];
		System.arraycopy(originalCP, 0, newCP, 0, originalCP.length);
		newCP[originalCP.length] = JavaCore.newLibraryEntry(new Path("/P/src/lib"), null, null);
		createFolder("/P/src/lib");
		
		IJavaModelStatus status = JavaConventions.validateClasspath(proj, newCP, proj.getOutputLocation());
		

		// at this point, a marker indicates that test185733.jar has been created: "Project 'P' is missing required library: '[...]\test185733.jar'"
		
		createFile(new File(getExternalPath()), "test185733.jar", "");
		refreshExternalArchives(p);
		assertMarkers(
			"Unexpected markers", 
			"",
			p);
	} finally {
		deleteResource(new File(externalJarPath));
		deleteProject("P");
	}
}

		waitForAutoBuild();
		// at this point, the project has no markers
		
		deleteResource(externalJar);
		refreshExternalArchives(p);
		assertMarkers(
			"Unexpected markers", 
			"Project \'P\' is missing required library: \'" + externalJar.getPath() + "\'",

	}
}
/*
 * Ensures that a file not ending with .jar or .zip can be put on the classpath.
 * (see https://bugs.eclipse.org/bugs/show_bug.cgi?id=182360 )
 */
public void testInvalidInternalJar2() throws CoreException {
	try {

		IJavaProject proj =  createJavaProject("P2", new String[] {}, new String[] {"/P1/existing.txt"}, "bin");
		assertMarkers(
			"Unexpected markers",
			"",
			proj);
	} finally {
		deleteProject("P1");

		IJavaProject javaProject = createJavaProject("P");
		IProject project = javaProject.getProject();
		project.close(null);
		deleteResource(new File(project.getLocation().toOSString(), ".classpath"));
		waitForAutoBuild();
		project.open(null);
		waitForAutoBuild();

public void testRemoveExternalLibFolder1() throws CoreException {
	try {
		createExternalFolder("externalLib");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		waitForAutoBuild();
		setClasspath(p, new IClasspathEntry[] {});
		assertMarkers("Unexpected markers", "", p);
	} finally {
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

 */
public void testRemoveExternalLibFolder2() throws CoreException {
	try {
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		waitForAutoBuild();
		setClasspath(p, new IClasspathEntry[] {});
		assertMarkers(

public void testRemoveExternalLibFolder3() throws CoreException {
	try {
		createExternalFolder("externalLib");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		waitForAutoBuild();
		deleteExternalResource("externalLib");
		refresh(p);
		assertMarkers(
			"Unexpected markers", 
			"Project \'P\' is missing required library: \'"+ getExternalPath() + "externalLib\'",
			p);
	} finally {
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

	try {
		simulateExitRestart();
		createExternalFolder("externalLib");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		waitForAutoBuild();
		deleteExternalResource("externalLib");
		refresh(p);
		assertMarkers(
			"Unexpected markers", 
			"Project \'P\' is missing required library: \'"+ getExternalPath() + "externalLib\'",
			p);
	} finally {
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

/*
 * Ensures that removing a library entry for an existing external ZIP archive doesn't generate a marker
 */
public void testRemoveZIPArchive1() throws CoreException {
	try {
		createExternalFile("externalLib.abc", "");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		waitForAutoBuild();
		setClasspath(p, new IClasspathEntry[] {});
		assertMarkers("Unexpected markers", "", p);
	} finally {
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		deleteProject("P");
	}
}

/*
 * Ensures that removing a library entry for a non-existing external ZIP archive removes the marker
 */
public void testRemoveZIPArchive2() throws CoreException {
	try {
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		waitForAutoBuild();
		setClasspath(p, new IClasspathEntry[] {});
		assertMarkers(
			"Unexpected markers", 
			"",
			p);
	} finally {
		deleteProject("P");
	}
}

/*
 * Ensures that removing an external ZIP archive referenced by a library entry creates a marker
 */
public void testRemoveZIPArchive3() throws CoreException {
	try {
		createExternalFile("externalLib.abc", "");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		waitForAutoBuild();
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		assertMarkers(
			"Unexpected markers", 
			"Project \'P\' is missing required library: \'"+ getExternalPath() + "externalLib.abc\'",
			p);
	} finally {
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		deleteProject("P");
	}
}

/*
 * Ensures that removing an external ZIP archive referenced by a library entry and refreshing after a restart
 * creates a marker
 */
public void testRemoveZIPArchive4() throws CoreException {
	try {
		simulateExitRestart();
		createExternalFile("externalLib.abc", "");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		waitForAutoBuild();
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		assertMarkers(
			"Unexpected markers", 
			"Project \'P\' is missing required library: \'"+ getExternalPath() + "externalLib.abc\'",
			p);
	} finally {
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		deleteProject("P");
	}
}

/*
 * Ensures that removing a library entry for an existing internal ZIP archive doesn't generate a marker
 */
public void testRemoveZIPArchive5() throws CoreException {
	try {
		IJavaProject p = createJavaProject("P", new String[0], new String[] {"/P/internalLib.abc"}, "");
		createFile("/P/internalLib.abc", "");
		waitForAutoBuild();
		setClasspath(p, new IClasspathEntry[] {});
		assertMarkers("Unexpected markers", "", p);
	} finally {
		deleteProject("P");
	}
}

/*
 * Ensures that removing an internal ZIP archive referenced by a library entry creates a marker
 */
public void testRemoveZIPArchive6() throws CoreException {
	try {
		IJavaProject p = createJavaProject("P", new String[0], new String[] {"/P/internalLib.abc"}, "");
		createFile("/P/internalLib.abc", "");
		waitForAutoBuild();
		deleteFile("/P/internalLib.abc");
		assertMarkers(
			"Unexpected markers", 
			"Project \'P\' is missing required library: \'internalLib.abc\'",
			p);
	} finally {
		deleteProject("P");
	}
}

Lines 123-130 Link Here

(-)src/org/eclipse/jdt/core/tests/model/ModifyingResourceTests.java (-2 / +6 lines)
123	protected IFolder createFolder(String path) throws CoreException {	123	protected IFolder createFolder(String path) throws CoreException {
124	return createFolder(new Path(path));	124	return createFolder(new Path(path));
125	}	125	}
126	protected void deleteExternalFolder(String relativePath) {	126	protected void deleteExternalResource(String relativePath) {
127	deleteFile(new File(getExternalPath() + relativePath));	127	deleteResource(new File(getExternalPath() + relativePath));
		128	}
		129	protected void deleteAndRefreshExternalZIPArchive(String relativePath, String referringProject) throws JavaModelException {
		130	deleteExternalResource(relativePath);
		131	refreshExternalArchives(getJavaProject(referringProject));
128	}	132	}
129	protected void deleteFile(String filePath) throws CoreException {	133	protected void deleteFile(String filePath) throws CoreException {
130	deleteResource(this.getFile(filePath));	134	deleteResource(this.getFile(filePath));

Lines 847-853 Link Here

(-)src/org/eclipse/jdt/core/tests/model/EncodingTests.java (-1 / +1 lines)
847	assertEquals("We should not get any character!", "", new String(ifileContents));	847	assertEquals("We should not get any character!", "", new String(ifileContents));
848		848
849	// Delete empty file	849	// Delete empty file
850	deleteFile(file);	850	deleteResource(file);
851	}	851	}
852		852
853	/**	853	/**

Lines 1191-1197 Link Here

(-)src/org/eclipse/jdt/core/tests/model/ReconcilerTests.java (-2 / +2 lines)
1191	);	1191	);
1192	} finally {	1192	} finally {
1193	removeClasspathEntry(project, new Path(jarPath));	1193	removeClasspathEntry(project, new Path(jarPath));
1194	deleteFile(new File(jarPath));	1194	deleteResource(new File(jarPath));
1195	}	1195	}
1196	}	1196	}
1197	/**	1197	/**
Lines 1284-1290 Link Here
1284	);	1284	);
1285	} finally {	1285	} finally {
1286	removeClasspathEntry(project, new Path(jarName));	1286	removeClasspathEntry(project, new Path(jarName));
1287	deleteFile(new File(jarName));	1287	deleteResource(new File(jarName));
1288	}	1288	}
1289	}	1289	}
1290	/**	1290	/**

Lines 138-144 Link Here

(-)src/org/eclipse/jdt/core/tests/model/SearchParticipantTests.java (-1 / +1 lines)
138		138
139	public void setUpSuite() throws Exception {	139	public void setUpSuite() throws Exception {
140	super.setUpSuite();	140	super.setUpSuite();
141	deleteFile(getIndexLocation().toFile());	141	deleteResource(getIndexLocation().toFile());
142	}	142	}
143		143
144	public void tearDownSuite() throws Exception {	144	public void tearDownSuite() throws Exception {

Lines 2607-2613 Link Here

(-)src/org/eclipse/jdt/core/tests/model/ResolveTests_1_5.java (-1 / +1 lines)
2607	"Member");	2607	"Member");
2608	assertEquals("test0114.Test.Member<java.lang.String>", ((IType)elements[0]).getFullyQualifiedParameterizedName());	2608	assertEquals("test0114.Test.Member<java.lang.String>", ((IType)elements[0]).getFullyQualifiedParameterizedName());
2609	} finally {	2609	} finally {
2610	deleteFile(rootLocation.append("test0114").toFile());	2610	deleteResource(rootLocation.append("test0114").toFile());
2611	}	2611	}
2612	}	2612	}
2613	}	2613	}

Lines 316-323 Link Here

(-)src/org/eclipse/jdt/core/tests/model/ExistenceTests.java (-2 / +2 lines)
316	*/	316	*/
317	public void testNonExistingExternalPackageFragmentRoot2() throws CoreException {	317	public void testNonExistingExternalPackageFragmentRoot2() throws CoreException {
318	try {	318	try {
319	IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalFolderPath("nonExisting")}, "");	319	IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("nonExisting")}, "");
320	IPackageFragmentRoot root = p.getPackageFragmentRoot(getExternalFolderPath("nonExisting"));	320	IPackageFragmentRoot root = p.getPackageFragmentRoot(getExternalResourcePath("nonExisting"));
321	assertFalse("root should not exist", root.exists());	321	assertFalse("root should not exist", root.exists());
322	} finally {	322	} finally {
323	deleteProject("P");	323	deleteProject("P");




		createExternalFolder("externalLib");
		refresh(p);
		startDeltas();
		setClasspath(p, new IClasspathEntry[] {JavaCore.newLibraryEntry(new Path(getExternalResourcePath("externalLib")), null, null)});
		assertDeltas(
			"Unexpected delta", 
			"P[*]: {CHILDREN | CONTENT | RAW CLASSPATH CHANGED | RESOLVED CLASSPATH CHANGED}\n" + 

		);
	} finally {
		stopDeltas();
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

	try {
		IJavaProject p = createJavaProject("P");
		refresh(p);
		IPath path = new Path(getExternalResourcePath("externalLib"));
		startDeltas();
		setClasspath(p, new IClasspathEntry[] {JavaCore.newLibraryEntry(path, null, null)});
		assertDeltas(

 */
public void testAddExternalLibFolder3() throws CoreException {
	try {
		IJavaProject p =createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		startDeltas();
		createExternalFolder("externalLib");
		refresh(p);

		);
	} finally {
		stopDeltas();
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

public void testAddExternalLibFolder4() throws CoreException {
	try {
		simulateExitRestart();
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		startDeltas();
		createExternalFolder("externalLib");
		refresh(p);

		);
	} finally {
		stopDeltas();
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

/*
 * Ensures that adding a library entry for an existing external ZIP archive triggers the correct delta
 */
public void testAddZIPArchive1() throws CoreException {
	try {
		IJavaProject p = createJavaProject("P");
		createExternalFile("externalLib.abc", "");
		startDeltas();
		setClasspath(p, new IClasspathEntry[] {JavaCore.newLibraryEntry(new Path(getExternalResourcePath("externalLib.abc")), null, null)});
		assertDeltas(
			"Unexpected delta", 
			"P[*]: {CHILDREN | CONTENT | RAW CLASSPATH CHANGED | RESOLVED CLASSPATH CHANGED}\n" + 
			"	<project root>[*]: {REMOVED FROM CLASSPATH}\n" + 
			"	"+ getExternalPath() + "externalLib.abc[+]: {}\n" + 
			"	"+ getExternalJCLPathString() + "[*]: {REMOVED FROM CLASSPATH}\n" + 
			"	ResourceDelta(/P/.classpath)[*]"
		);
	} finally {
		stopDeltas();
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		deleteProject("P");
	}
}

/*
 * Ensures that adding a library entry for a non-existing external ZIP archive triggers the correct delta
 */
public void testAddZIPArchive2() throws CoreException {
	try {
		IJavaProject p = createJavaProject("P");
		IPath path = new Path(getExternalResourcePath("externalLib.abc"));
		startDeltas();
		setClasspath(p, new IClasspathEntry[] {JavaCore.newLibraryEntry(path, null, null)});
		assertDeltas(
			"Unexpected delta", 
			"P[*]: {CHILDREN | CONTENT | RAW CLASSPATH CHANGED | RESOLVED CLASSPATH CHANGED}\n" + 
			"	<project root>[*]: {REMOVED FROM CLASSPATH}\n" + 
			"	"+ getExternalJCLPathString() + "[*]: {REMOVED FROM CLASSPATH}\n" + 
			"	ResourceDelta(/P/.classpath)[*]"
		);
	} finally {
		stopDeltas();
		deleteProject("P");
	}
}

/*
 * Ensures that creating an external ZIP archive referenced by a library entry and refreshing triggers the correct delta
 */
public void testAddZIPArchive3() throws CoreException {
	try {
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		startDeltas();
		createExternalFile("externalLib.abc", "");
		refreshExternalArchives(p);
		assertDeltas(
			"Unexpected delta", 
			"P[*]: {CHILDREN}\n" + 
			"	"+ getExternalPath() + "externalLib.abc[+]: {}"
		);
	} finally {
		stopDeltas();
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		deleteProject("P");
	}
}

/*
 * Ensures that creating an external ZIP archive referenced by a library entry and refreshing after a restart triggers the correct delta
 */
public void testAddZIPArchive4() throws CoreException {
	try {
		simulateExitRestart();
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		startDeltas();
		createExternalFile("externalLib.abc", "");
		refreshExternalArchives(p);
		assertDeltas(
			"Unexpected delta", 
			"P[*]: {CHILDREN}\n" + 
			"	"+ getExternalPath() + "externalLib.abc[+]: {}"
		);
	} finally {
		stopDeltas();
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		deleteProject("P");
	}
}

/*
 * Ensures that adding a library entry for an existing internal ZIP archive triggers the correct delta
 */
public void testAddZIPArchive5() throws CoreException {
	try {
		IJavaProject p = createJavaProject("P");
		createFile("/P/internalLib.abc", "");
		startDeltas();
		setClasspath(p, new IClasspathEntry[] {JavaCore.newLibraryEntry(new Path("/P/internalLib.abc"), null, null)});
		assertDeltas(
			"Unexpected delta", 
			"P[*]: {CHILDREN | CONTENT | RAW CLASSPATH CHANGED | RESOLVED CLASSPATH CHANGED}\n" + 
			"	<project root>[*]: {REMOVED FROM CLASSPATH}\n" + 
			"	internalLib.abc[*]: {ADDED TO CLASSPATH}\n" + 
			"	"+ getExternalJCLPathString() + "[*]: {REMOVED FROM CLASSPATH}\n" + 
			"	ResourceDelta(/P/.classpath)[*]"
		);
	} finally {
		stopDeltas();
		deleteProject("P");
	}
}

public void testChangeExternalLibFolder1() throws CoreException {
	try {
		createExternalFolder("externalLib");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		startDeltas();
		createExternalFolder("externalLib/p");
		refresh(p);

		);
	} finally {
		stopDeltas();
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

public void testChangeExternalLibFolder2() throws CoreException {
	try {
		createExternalFolder("externalLib/p");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		startDeltas();
		createExternalFile("externalLib/p/X.class", "");
		refresh(p);

		);
	} finally {
		stopDeltas();
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

	try {
		createExternalFolder("externalLib/p");
		createExternalFile("externalLib/p/X.class", "");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		startDeltas();
		touch(getExternalFile("externalLib/p/X.class"));
		refresh(p);

		);
	} finally {
		stopDeltas();
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

public void testChangeExternalLibFolder4() throws CoreException {
	try {
		createExternalFolder("externalLib");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		startDeltas();
		createExternalFile("externalLib/test.txt", "test");
		refresh(p);

		);
	} finally {
		stopDeltas();
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

public void testChangeExternalLibFolder5() throws CoreException {
	try {
		createExternalFolder("externalLib/p");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		startDeltas();
		createExternalFile("externalLib/p/test.txt", "test");
		refresh(p);

		);
	} finally {
		stopDeltas();
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

/*
 * Ensures that changing an external ZIP archive referenced by a library entry and refreshing triggers the correct delta
 */
public void testChangeZIPArchive1() throws CoreException {
	try {
		createExternalFile("externalLib.abc", "");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		refreshExternalArchives(p);
		startDeltas();
		touch(getExternalFile("externalLib.abc"));
		refreshExternalArchives(p);
		assertDeltas(
			"Unexpected delta", 
			"P[*]: {CHILDREN}\n" + 
			"	"+ getExternalPath() + "externalLib.abc[*]: {CONTENT | ARCHIVE CONTENT CHANGED}"
		);
	} finally {
		stopDeltas();
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		deleteProject("P");
	}
}

/*
 * Ensures that changing an internal ZIP archive referenced by a library entry triggers the correct delta
 */
public void testChangeZIPArchive2() throws CoreException {
	try {
		createJavaProject("P", new String[0], new String[] {"/P/internalLib.abc"}, "");
		createFile("/P/internalLib.abc", "");
		startDeltas();
		editFile("/P/internalLib.abc", "");
		assertDeltas(
			"Unexpected delta", 
			"P[*]: {CHILDREN}\n" + 
			"	internalLib.abc[*]: {CONTENT | ARCHIVE CONTENT CHANGED}"
		);
	} finally {
		stopDeltas();
		deleteProject("P");
	}
}

		createExternalFolder("externalLib");
		createExternalFolder("externalSrc");
		IJavaProject project = createJavaProject("P");
		addLibraryEntry(project, getExternalResourcePath("externalLib"), getExternalResourcePath("externalSrc"));
		startDeltas();
		createExternalFile("externalSrc/X.java", "public class X {}");
		refresh(project);

			);
	} finally {
		stopDeltas();
		deleteExternalResource("externalLib");
		deleteExternalResource("externalSrc");
		deleteProject("P");
	}
}

public void testRemoveExternalLibFolder1() throws CoreException {
	try {
		createExternalFolder("externalLib");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		startDeltas();
		setClasspath(p, new IClasspathEntry[] {});
		assertDeltas(

		);
	} finally {
		stopDeltas();
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

 */
public void testRemoveExternalLibFolder2() throws CoreException {
	try {
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		startDeltas();
		setClasspath(p, new IClasspathEntry[] {});
		assertDeltas(

public void testRemoveExternalLibFolder3() throws CoreException {
	try {
		createExternalFolder("externalLib");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		startDeltas();
		deleteExternalResource("externalLib");
		refresh(p);
		assertDeltas(
			"Unexpected delta", 

		);
	} finally {
		stopDeltas();
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

	try {
		simulateExitRestart();
		createExternalFolder("externalLib");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		startDeltas();
		deleteExternalResource("externalLib");
		refresh(p);
		assertDeltas(
			"Unexpected delta", 

		);
	} finally {
		stopDeltas();
		deleteExternalResource("externalLib");
		deleteProject("P");
	}
}

/*
 * Ensures that removing a library entry for an existing external ZIP archive triggers the correct delta
 */
public void testRemoveZIPArchive1() throws CoreException {
	try {
		createExternalFile("externalLib.abc", "");
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		startDeltas();
		setClasspath(p, new IClasspathEntry[] {});
		assertDeltas(
			"Unexpected delta", 
			"P[*]: {CHILDREN | CONTENT | RAW CLASSPATH CHANGED | RESOLVED CLASSPATH CHANGED}\n" + 
			"	"+ getExternalPath() + "externalLib.abc[*]: {REMOVED FROM CLASSPATH}\n" + 
			"	ResourceDelta(/P/.classpath)[*]"
		);
	} finally {
		stopDeltas();
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		deleteProject("P");
	}
}

/*
 * Ensures that removing a library entry for a non-existing external ZIP archive triggers the correct delta
 */
public void testRemoveZIPArchive2() throws CoreException {
	try {
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		startDeltas();
		setClasspath(p, new IClasspathEntry[] {});
		assertDeltas(
			"Unexpected delta", 
			"P[*]: {CHILDREN | CONTENT | RAW CLASSPATH CHANGED | RESOLVED CLASSPATH CHANGED}\n" + 
			"	"+ getExternalPath() + "externalLib.abc[*]: {REMOVED FROM CLASSPATH}\n" + 
			"	ResourceDelta(/P/.classpath)[*]"		);
	} finally {
		stopDeltas();
		deleteProject("P");
	}
}

/*
 * Ensures that removing an external ZIP archive referenced by a library entry triggers the correct delta
 */
public void testRemoveZIPArchive3() throws CoreException {
	try {
		createExternalFile("externalLib.abc", "");
		createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		startDeltas();
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		assertDeltas(
			"Unexpected delta", 
			"P[*]: {CHILDREN}\n" + 
			"	"+ getExternalPath() + "externalLib.abc[-]: {}"
		);
	} finally {
		stopDeltas();
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		deleteProject("P");
	}
}

/*
 * Ensures that removing an external ZIP archive referenced by a library entry after a restart
 * triggers the correct delta
 */
public void testRemoveZIPArchive4() throws CoreException {
	try {
		simulateExitRestart();
		createExternalFile("externalLib.abc", "");
		createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		startDeltas();
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		assertDeltas(
			"Unexpected delta", 
			"P[*]: {CHILDREN}\n" + 
			"	"+ getExternalPath() + "externalLib.abc[-]: {}"
		);
	} finally {
		stopDeltas();
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		deleteProject("P");
	}
}

/*
 * Ensures that removing a library entry for an existing internal ZIP archive triggers the correct delta
 */
public void testRemoveZIPArchive5() throws CoreException {
	try {
		IJavaProject p = createJavaProject("P", new String[0], new String[] {"/P/internalLib.abc"}, "");
		createFile("/P/internalLib.abc", "");
		startDeltas();
		setClasspath(p, new IClasspathEntry[] {});
		assertDeltas(
			"Unexpected delta", 
			"P[*]: {CHILDREN | CONTENT | RAW CLASSPATH CHANGED | RESOLVED CLASSPATH CHANGED}\n" + 
			"	internalLib.abc[*]: {REMOVED FROM CLASSPATH}\n" + 
			"	ResourceDelta(/P/.classpath)[*]"
		);
	} finally {
		stopDeltas();
		deleteProject("P");
	}
}




		"", 
		this.resultCollector);
}

/*
 * Ensures that a method declaration in an external library folder can be found
 */

				"}"
			},
			new HashMap(),
			getExternalResourcePath("externalLib")
		);
		createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaProject[] {getJavaProject("P")});
		search("foo", METHOD, DECLARATIONS, scope);
		assertSearchResults(

			this.resultCollector);
	} finally {
		deleteProject("P");
		deleteExternalResource("externalLib");
	}
}


				"}"
			},
			new HashMap(),
			getExternalResourcePath("externalLib")
		);
		createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		
		TypeNameMatchCollector collector = new TypeNameMatchCollector();
		new SearchEngine(this.workingCopies).searchAllTypeNames(

		);
	} finally {
		deleteProject("P");
		deleteExternalResource("externalLib");
	}

}

/*
 * Ensures that a method declaration in an external ZIP archive can be found
 */
public void testZIPArchive1() throws Exception {
	try {
		org.eclipse.jdt.core.tests.util.Util.createJar(
			new String[] {
				"p/X.java", 
				"package p;\n" +
				"public class X {\n" +
				"  public void foo() {\n" +
				"  }\n" +
				"}"
			},
			getExternalResourcePath("externalLib.abc"), 
			"1.4");
		createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaProject[] {getJavaProject("P")});
		search("foo", METHOD, DECLARATIONS, scope);
		assertSearchResults(
			getExternalPath() + "externalLib.abc void p.X.foo()",
			this.resultCollector);
	} finally {
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		deleteProject("P");
	}
}

/*
 * Ensures that search all type names returns the types in an external ZIP archive
 */
public void testZIPArchive2() throws Exception {
	try {
		IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		org.eclipse.jdt.core.tests.util.Util.createJar(
			new String[] {
				"p/ExternalType.java", 
				"package p;\n" +
				"public class ExternalType {\n" +
				"}"
			},
			getExternalResourcePath("externalLib.abc"), 
			"1.4");
		refreshExternalArchives(p);
		
		TypeNameMatchCollector collector = new TypeNameMatchCollector();
		new SearchEngine(this.workingCopies).searchAllTypeNames(
			null,
			SearchPattern.R_EXACT_MATCH,
			"ExternalType".toCharArray(),
			SearchPattern.R_EXACT_MATCH,
			TYPE,
			SearchEngine.createJavaSearchScope(new IJavaProject[] {getJavaProject("P")}),
			collector,
			IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
			null
		);
		assertSearchResults(
			"ExternalType (not open) [in ExternalType.class [in p [in "+ getExternalPath() + "externalLib.abc]]]",
			collector
		);
	} finally {
		deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		deleteProject("P");
	}

}

/**
 * Simple field declaration test.
 */




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.*;
import org.eclipse.jdt.core.search.IJavaSearchConstants;
import org.eclipse.jdt.core.search.IJavaSearchScope;

	try {
		createExternalFolder("externalLib/p");
		createExternalFile("externalLib/p/X.class", "");
		createJavaProject("P1", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
		IClassFile classFile1 = getClassFile("P1", getExternalResourcePath("externalLib"), "p", "X.class");
		assertResourceEquals(
			"Unexpected resource",
			"<null>",
			classFile1.getResource());
	} finally {
		deleteExternalResource("externalLib");
		deleteProject("P1");
	}
}

		} catch (JavaModelException e) {
			expected = e;
		}
		assertExceptionEquals("Unexpected exception", new Path("/P1/classFolder.jar").toOSString() + " does not exist", expected);
	} finally {
		deleteProject("P1");
	}

Lines 1467-1476 Link Here

(-)src/org/eclipse/jdt/core/tests/model/AbstractJavaModelTests.java (-6 / +17 lines)
1467	getWorkspace().run(create, null);	1467	getWorkspace().run(create, null);
1468	return project;	1468	return project;
1469	}	1469	}
1470	public void deleteFile(File file) {	1470	public void deleteResource(File resource) {
1471	int retryCount = 0;	1471	int retryCount = 0;
1472	while (++retryCount <= 60) { // wait 1 minute at most	1472	while (++retryCount <= 60) { // wait 1 minute at most
1473	if (org.eclipse.jdt.core.tests.util.Util.delete(file)) {	1473	if (org.eclipse.jdt.core.tests.util.Util.delete(resource)) {
1474	break;	1474	break;
1475	}	1475	}
1476	}	1476	}
Lines 1649-1655 Link Here
1649	return new File(getExternalPath(), relativePath);	1649	return new File(getExternalPath(), relativePath);
1650	}	1650	}
1651		1651
1652	protected String getExternalFolderPath(String name) {	1652	protected String getExternalResourcePath(String name) {
1653	return getExternalPath() + name;	1653	return getExternalPath() + name;
1654	}	1654	}
1655		1655
Lines 2029-2034 Link Here
2029	waitForManualRefresh();	2029	waitForManualRefresh();
2030	}	2030	}
2031		2031
		2032	protected void refreshExternalArchives(IJavaProject p) throws JavaModelException {
		2033	getJavaModel().refreshExternalArchives(new IJavaElement[] {p}, null);
		2034	}
		2035
2032	protected void removeJavaNature(String projectName) throws CoreException {	2036	protected void removeJavaNature(String projectName) throws CoreException {
2033	IProject project = this.getProject(projectName);	2037	IProject project = this.getProject(projectName);
2034	IProjectDescription description = project.getDescription();	2038	IProjectDescription description = project.getDescription();
Lines 2658-2667 Link Here
2658	}	2662	}
2659	return result;	2663	return result;
2660	}	2664	}
2661	protected void touch(File f) {	2665	protected synchronized void touch(File f) {
2662	f.setLastModified(f.lastModified() + 10000);	2666	f.setLastModified(f.lastModified() + 1000);
		2667	long start = System.currentTimeMillis();
		2668	do {
		2669	try {
		2670	wait(1000);
		2671	} catch (InterruptedException e) {
		2672	}
		2673	} while ((System.currentTimeMillis() - start) < 1000);
2663	}	2674	}
2664	protected String toString(String[] strings) {	2675	protected String toString(String[] strings) {
2665	return toString(strings, false/don't add extra new line/);	2676	return toString(strings, false/don't add extra new line/);
2666	}	2677	}
2667	protected String toString(String[] strings, boolean addExtraNewLine) {	2678	protected String toString(String[] strings, boolean addExtraNewLine) {




	public void addExternalJars(IPath projectPath, String[] jars, boolean isExported) throws JavaModelException {
		for (int i = 0, max = jars.length; i < max; i++) {
			String jar = jars[i];
			checkAssertion("file name must end with .zip or .jar", jar.endsWith(".zip") || jar.endsWith(".jar")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
			addEntry(projectPath, JavaCore.newLibraryEntry(new Path(jar), null, null, isExported));
		}
	}

	/** Adds an external jar to the classpath of a project.
	 */
	public void addExternalJar(IPath projectPath, String jar, boolean isExported) throws JavaModelException {
		checkAssertion("file name must end with .zip or .jar", jar.endsWith(".zip") || jar.endsWith(".jar")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		addEntry(projectPath, JavaCore.newLibraryEntry(new Path(jar), null, null, isExported));
	}
	

	addEntry(projectPath, 		
		JavaCore.newLibraryEntry(libraryPath, sourceAttachmentPath,	sourceAttachmentRootPath));
}
	public void addEntry(IPath projectPath, IClasspathEntry entryPath) throws JavaModelException {
		IClasspathEntry[] classpath = getClasspath(projectPath);
		IClasspathEntry[] newClaspath = new IClasspathEntry[classpath.length + 1];
		System.arraycopy(classpath, 0, newClaspath, 0, classpath.length);


	/** Adds a jar with the given contents to the the workspace.
	 * If a jar with the same name already exists, it is
	 * replaced.  A workspace must be open.  Returns the path of
	 * zip name must end with ".zip" or ".jar".  Returns the path of
	 * the added jar.
	 */
	public IPath addInternalJar(IPath projectPath, String zipName, byte[] contents, boolean isExported) throws JavaModelException {
		checkAssertion("a workspace must be open", fIsOpen); //$NON-NLS-1$
		checkAssertion("zipName must end with .zip or .jar", zipName.endsWith(".zip") || zipName.endsWith(".jar")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		IPath path = projectPath.append(zipName);
		
		/* remove any existing zip from the java model */




}

/*
 * Ensures that changing a type in an external folder and refreshing triggers a rebuild
 */
public void testChangeExternalFolder() throws CoreException {
	String externalLib = Util.getOutputDirectory() + File.separator + "externalLib";

}

/*
 * Ensures that changing a type in an external ZIP archive and refreshing triggers a rebuild
 */
public void testChangeZIPArchive1() throws Exception {
	String externalLib = Util.getOutputDirectory() + File.separator + "externalLib.abc";
	try {
		org.eclipse.jdt.core.tests.util.Util.createJar(
			new String[] {
				"p/X.java",
				"package p;\n" +
				"public class X {\n" +
				"  public void foo() {\n" +
				"  }\n" +
				"}"
			},
			externalLib, 
			"1.4");
		
		IPath projectPath = env.addProject("Project"); 
		env.addExternalJars(projectPath, Util.getJavaClassLibs());
		env.addExternalJars(projectPath, new String[] {externalLib});

		IPath root = env.getPackageFragmentRootPath(projectPath, ""); //$NON-NLS-1$
		env.setOutputFolder(projectPath, ""); 

		IPath classY = env.addClass(root, "q", "Y",  
			"package q;\n"+ 
			"public class Y {\n" +
			"  void bar(p.X x) {\n" +
			"    x.foo();\n" +
			"  }\n" +
			"}"
		); 

		fullBuild(projectPath);
		expectingNoProblems();

		long lastModified = new java.io.File(externalLib).lastModified();
		try {
			Thread.sleep(1000);
		} catch(InterruptedException e) {
		}
		org.eclipse.jdt.core.tests.util.Util.createJar(
			new String[] {
				"p/X.java",
				"package p;\n" +
				"public class X {\n" +
				"}"
			},
			externalLib, 
			"1.4");
		new java.io.File(externalLib).setLastModified(lastModified + 1000); // to be sure its different
		
		IJavaProject p = env.getJavaProject(projectPath);
		p.getJavaModel().refreshExternalArchives(new IJavaElement[] {p}, null);

		incrementalBuild(projectPath);
		expectingProblemsFor(
			classY,
			"Problem : The method foo() is undefined for the type X [ resource : </Project/q/Y.java> range : <54,57> category : <50> severity : <2>]"
		);
	} finally {
		new File(externalLib).delete();
	}
}

/*
 * Ensures that changing a type in an internal ZIP archive and refreshing triggers a rebuild
 */
public void testChangeZIPArchive2() throws Exception {
	IPath projectPath = env.addProject("Project"); 
	String internalLib = env.getProject("Project").getLocation().toOSString() + File.separator + "internalLib.abc";
	env.addExternalJars(projectPath, Util.getJavaClassLibs());
	env.addEntry(projectPath, JavaCore.newLibraryEntry(new Path("/Project/internalLib.abc"), null, null));
	org.eclipse.jdt.core.tests.util.Util.createJar(
		new String[] {
			"p/X.java",
			"package p;\n" +
			"public class X {\n" +
			"  public void foo() {\n" +
			"  }\n" +
			"}"
		},
		internalLib, 
		"1.4");
	env.getProject(projectPath).refreshLocal(IResource.DEPTH_INFINITE, null);

	IPath root = env.getPackageFragmentRootPath(projectPath, ""); //$NON-NLS-1$
	env.setOutputFolder(projectPath, ""); 

	IPath classY = env.addClass(root, "q", "Y",  
		"package q;\n"+ 
		"public class Y {\n" +
		"  void bar(p.X x) {\n" +
		"    x.foo();\n" +
		"  }\n" +
		"}"
	); 

	fullBuild(projectPath);
	expectingNoProblems();

	long lastModified = new java.io.File(internalLib).lastModified();
	try {
		Thread.sleep(1000);
	} catch(InterruptedException e) {
	}
	org.eclipse.jdt.core.tests.util.Util.createJar(
		new String[] {
			"p/X.java",
			"package p;\n" +
			"public class X {\n" +
			"}"
		},
		internalLib, 
		"1.4");
	new java.io.File(internalLib).setLastModified(lastModified + 1000); // to be sure its different
	
	env.getProject(projectPath).refreshLocal(IResource.DEPTH_INFINITE, null);

	incrementalBuild(projectPath);
	expectingProblemsFor(
		classY,
		"Problem : The method foo() is undefined for the type X [ resource : </Project/q/Y.java> range : <54,57> category : <50> severity : <2>]"
	);
}

/*
 * Ensures that changing an external jar and refreshing the projects triggers a rebuild
 * (regression test for bug 50207 Compile errors fixed by 'refresh' do not reset problem list or package explorer error states)
 */

Return to bug 182360

Lines 1484-1501 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/BatchCompilerTest.java (-7 / +63 lines)
1484	" with ''+''.\n" +	1484	" with ''+''.\n" +
1485	" \n" +	1485	" \n" +
1486	" Classpath options:\n" +	1486	" Classpath options:\n" +
1487	" -cp -classpath <directories and zip/jar files separated by " + File.pathSeparator + ">\n" +	1487	" -cp -classpath <directories and ZIP archives separated by " + File.pathSeparator + ">\n" +
1488	" specify location for application classes and sources.\n" +	1488	" specify location for application classes and sources.\n" +
1489	" Each directory or file can specify access rules for\n" +	1489	" Each directory or file can specify access rules for\n" +
1490	" types between ''['' and '']'' (e.g. [-X] to forbid\n" +	1490	" types between ''['' and '']'' (e.g. [-X] to forbid\n" +
1491	" access to type X, [~X] to discourage access to type X,\n" +	1491	" access to type X, [~X] to discourage access to type X,\n" +
1492	" [+p/X" + File.pathSeparator + "-p/*] to forbid access to all types in package p\n" +	1492	" [+p/X" + File.pathSeparator + "-p/*] to forbid access to all types in package p\n" +
1493	" but allow access to p/X)\n" +	1493	" but allow access to p/X)\n" +
1494	" -bootclasspath <directories and zip/jar files separated by " + File.pathSeparator + ">\n" +	1494	" -bootclasspath <directories and ZIP archives separated by " + File.pathSeparator + ">\n" +
1495	" specify location for system classes. Each directory or\n" +	1495	" specify location for system classes. Each directory or\n" +
1496	" file can specify access rules for types between ''[''\n" +	1496	" file can specify access rules for types between ''[''\n" +
1497	" and '']''\n" +	1497	" and '']''\n" +
1498	" -sourcepath <directories and zip/jar files separated by " + File.pathSeparator + ">\n" +	1498	" -sourcepath <directories and ZIP archives separated by " + File.pathSeparator + ">\n" +
1499	" specify location for application sources. Each directory\n" +	1499	" specify location for application sources. Each directory\n" +
1500	" or file can specify access rules for types between ''[''\n" +	1500	" or file can specify access rules for types between ''[''\n" +
1501	" and '']''. Each directory can further specify a specific\n" +	1501	" and '']''. Each directory can further specify a specific\n" +
Lines 1503-1514 Link Here
1503	" and '']''; this overrides the general ''-d'' option.\n" +	1503	" and '']''; this overrides the general ''-d'' option.\n" +
1504	" .class files created from source files contained in a\n" +	1504	" .class files created from source files contained in a\n" +
1505	" jar file are put in the user.dir folder in case no\n" +	1505	" jar file are put in the user.dir folder in case no\n" +
1506	" general ''-d'' option is specified. zip/jar files cannot\n" +	1506	" general ''-d'' option is specified. ZIP archives cannot\n" +
1507	" override the general ''-d'' option\n" +	1507	" override the general ''-d'' option\n" +
1508	" -extdirs <directories separated by " + File.pathSeparator + ">\n" +	1508	" -extdirs <directories separated by " + File.pathSeparator + ">\n" +
1509	" specify location for extension zip/jar files\n" +	1509	" specify location for extension ZIP archives\n" +
1510	" -endorseddirs <directories separated by " + File.pathSeparator + ">\n" +	1510	" -endorseddirs <directories separated by " + File.pathSeparator + ">\n" +
1511	" specify location for endorsed zip/jar files\n" +	1511	" specify location for endorsed ZIP archives\n" +
1512	" -d <dir> destination directory (if omitted, no directory is\n" +	1512	" -d <dir> destination directory (if omitted, no directory is\n" +
1513	" created); this option can be overridden per source\n" +	1513	" created); this option can be overridden per source\n" +
1514	" directory\n" +	1514	" directory\n" +
Lines 1544-1550 Link Here
1544	" Annotation processing options:\n" +	1544	" Annotation processing options:\n" +
1545	" These options are meaningful only in a 1.6 environment.\n" +	1545	" These options are meaningful only in a 1.6 environment.\n" +
1546	" -Akey[=value] options that are passed to annotation processors\n" +	1546	" -Akey[=value] options that are passed to annotation processors\n" +
1547	" -processorpath <directories and zip/jar files separated by " + File.pathSeparator + ">\n" +	1547	" -processorpath <directories and ZIP archives separated by " + File.pathSeparator + ">\n" +
1548	" specify locations where to find annotation processors.\n" +	1548	" specify locations where to find annotation processors.\n" +
1549	" If this option is not used, the classpath will be\n" +	1549	" If this option is not used, the classpath will be\n" +
1550	" searched for processors\n" +	1550	" searched for processors\n" +
Lines 10798-10801 Link Here
10798	this.verifier.execute("Y", new String[] {OUTPUT_DIR });	10798	this.verifier.execute("Y", new String[] {OUTPUT_DIR });
10799	assertTrue(this.verifier.getExecutionOutput().startsWith("1")); // skip trailing newline	10799	assertTrue(this.verifier.getExecutionOutput().startsWith("1")); // skip trailing newline
10800	}	10800	}
		10801
		10802	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=182360
		10803	public void test281_classpath() {
		10804	runConformTest(
		10805	new String[] {
		10806	"src1/X.java",
		10807	"public class X {\n" +
		10808	"}",
		10809	},
		10810	"\"" + OUTPUT_DIR + File.separator + "src1/X.java\" -cp Y.java",
		10811	"" /* expectedOutOutputString */,
		10812	"incorrect classpath: Y.java\n",
		10813	false/shouldFlushOutput/);
		10814	}
		10815
		10816	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=182360
		10817	public void test282_classpath() {
		10818	runConformTest(
		10819	new String[] {
		10820	"src1/X.java",
		10821	"public class X {\n" +
		10822	"}",
		10823	},
		10824	"\"" + OUTPUT_DIR + File.separator + "src1/X.java\" -cp p/Y.java",
		10825	"" /* expectedOutOutputString */,
		10826	"incorrect classpath: p/Y.java\n",
		10827	false/shouldFlushOutput/);
		10828	}
		10829
		10830	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=182360
		10831	public void test283_classpath() {
		10832	runConformTest(
		10833	new String[] {
		10834	"src1/X.java",
		10835	"public class X {\n" +
		10836	"}",
		10837	},
		10838	"\"" + OUTPUT_DIR + File.separator + "src1/X.java\" -cp Y.class",
		10839	"" /* expectedOutOutputString */,
		10840	"incorrect classpath: Y.class\n",
		10841	false/shouldFlushOutput/);
		10842	}
		10843
		10844	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=182360
		10845	public void test284_classpath() {
		10846	runConformTest(
		10847	new String[] {
		10848	"src1/X.java",
		10849	"public class X {\n" +
		10850	"}",
		10851	},
		10852	"\"" + OUTPUT_DIR + File.separator + "src1/X.java\" -cp p/Y.class",
		10853	"" /* expectedOutOutputString */,
		10854	"incorrect classpath: p/Y.class\n",
		10855	false/shouldFlushOutput/);
		10856	}
10801	}	10857	}

Lines 479-485 Link Here

(-)model/org/eclipse/jdt/internal/core/JavaProject.java (-68 / +53 lines)
479	* @param accumulatedRoots ObjectVector	479	* @param accumulatedRoots ObjectVector
480	* @param rootIDs HashSet	480	* @param rootIDs HashSet
481	* @param referringEntry the CP entry (project) referring to this entry, or null if initial project	481	* @param referringEntry the CP entry (project) referring to this entry, or null if initial project
482	* @param checkExistency boolean
483	* @param retrieveExportedRoots boolean	482	* @param retrieveExportedRoots boolean
484	* @throws JavaModelException	483	* @throws JavaModelException
485	*/	484	*/
Lines 488-494 Link Here
488	ObjectVector accumulatedRoots,	487	ObjectVector accumulatedRoots,
489	HashSet rootIDs,	488	HashSet rootIDs,
490	IClasspathEntry referringEntry,	489	IClasspathEntry referringEntry,
491	boolean checkExistency,
492	boolean retrieveExportedRoots,	490	boolean retrieveExportedRoots,
493	Map rootToResolvedEntries) throws JavaModelException {	491	Map rootToResolvedEntries) throws JavaModelException {
494		492
Lines 506-546 Link Here
506	case IClasspathEntry.CPE_SOURCE :	504	case IClasspathEntry.CPE_SOURCE :
507		505
508	if (projectPath.isPrefixOf(entryPath)){	506	if (projectPath.isPrefixOf(entryPath)){
509	if (checkExistency) {	507	Object target = JavaModel.getTarget(entryPath, true/check existency/);
510	Object target = JavaModel.getTarget(entryPath, checkExistency);	508	if (target == null) return;
511	if (target == null) return;	509
512		510	if (target instanceof IFolder \|\| target instanceof IProject){
513	if (target instanceof IFolder \|\| target instanceof IProject){	511	root = getPackageFragmentRoot((IResource)target);
514	root = getPackageFragmentRoot((IResource)target);
515	}
516	} else {
517	root = getFolderPackageFragmentRoot(entryPath);
518	}	512	}
519	}	513	}
520	break;	514	break;
521		515
522	// internal/external JAR or folder	516	// internal/external JAR or folder
523	case IClasspathEntry.CPE_LIBRARY :	517	case IClasspathEntry.CPE_LIBRARY :
524		518	if (referringEntry != null && !resolvedEntry.isExported())
525	if (referringEntry != null && !resolvedEntry.isExported()) return;	519	return;
526		520	Object target = JavaModel.getTarget(entryPath, true/check existency/);
527	if (checkExistency) {	521	if (target == null)
528	Object target = JavaModel.getTarget(entryPath, checkExistency);	522	return;
529	if (target == null) return;	523
530		524	if (target instanceof IResource){
531	if (target instanceof IResource){	525	// internal target
532	// internal target	526	root = getPackageFragmentRoot((IResource) target, entryPath);
533	root = getPackageFragmentRoot((IResource) target, entryPath);	527	} else if (target instanceof File) {
534	} else if (target instanceof File) {	528	// external target
535	// external target	529	if (JavaModel.isFile(target)) {
536	if (JavaModel.isFile(target) && (org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(entryPath.lastSegment()))) {	530	root = new JarPackageFragmentRoot(entryPath, this);
537	root = new JarPackageFragmentRoot(entryPath, this);	531	} else if (((File) target).isDirectory()) {
538	} else if (((File) target).isDirectory()) {	532	root = new ExternalPackageFragmentRoot(entryPath, this);
539	root = new ExternalPackageFragmentRoot(entryPath, this);
540	}
541	}	533	}
542	} else {
543	root = getPackageFragmentRoot(entryPath);
544	}	534	}
545	break;	535	break;
546		536
Lines 561-567 Link Here
561	accumulatedRoots,	551	accumulatedRoots,
562	rootIDs,	552	rootIDs,
563	rootToResolvedEntries == null ? resolvedEntry : ((ClasspathEntry)resolvedEntry).combineWith((ClasspathEntry) referringEntry), // only combine if need to build the reverse map	553	rootToResolvedEntries == null ? resolvedEntry : ((ClasspathEntry)resolvedEntry).combineWith((ClasspathEntry) referringEntry), // only combine if need to build the reverse map
564	checkExistency,
565	retrieveExportedRoots,	554	retrieveExportedRoots,
566	rootToResolvedEntries);	555	rootToResolvedEntries);
567	}	556	}
Lines 596-602 Link Here
596	accumulatedRoots,	585	accumulatedRoots,
597	new HashSet(5), // rootIDs	586	new HashSet(5), // rootIDs
598	null, // inside original project	587	null, // inside original project
599	true, // check existency
600	retrieveExportedRoots,	588	retrieveExportedRoots,
601	rootToResolvedEntries);	589	rootToResolvedEntries);
602	IPackageFragmentRoot[] rootArray = new IPackageFragmentRoot[accumulatedRoots.size()];	590	IPackageFragmentRoot[] rootArray = new IPackageFragmentRoot[accumulatedRoots.size()];
Lines 613-619 Link Here
613	* @param accumulatedRoots ObjectVector	601	* @param accumulatedRoots ObjectVector
614	* @param rootIDs HashSet	602	* @param rootIDs HashSet
615	* @param referringEntry project entry referring to this CP or null if initial project	603	* @param referringEntry project entry referring to this CP or null if initial project
616	* @param checkExistency boolean
617	* @param retrieveExportedRoots boolean	604	* @param retrieveExportedRoots boolean
618	* @throws JavaModelException	605	* @throws JavaModelException
619	*/	606	*/
Lines 622-628 Link Here
622	ObjectVector accumulatedRoots,	609	ObjectVector accumulatedRoots,
623	HashSet rootIDs,	610	HashSet rootIDs,
624	IClasspathEntry referringEntry,	611	IClasspathEntry referringEntry,
625	boolean checkExistency,
626	boolean retrieveExportedRoots,	612	boolean retrieveExportedRoots,
627	Map rootToResolvedEntries) throws JavaModelException {	613	Map rootToResolvedEntries) throws JavaModelException {
628		614
Lines 635-641 Link Here
635	accumulatedRoots,	621	accumulatedRoots,
636	rootIDs,	622	rootIDs,
637	referringEntry,	623	referringEntry,
638	checkExistency,
639	retrieveExportedRoots,	624	retrieveExportedRoots,
640	rootToResolvedEntries);	625	rootToResolvedEntries);
641	}	626	}
Lines 1622-1652 Link Here
1622	path = getPath().append(path);	1607	path = getPath().append(path);
1623	}	1608	}
1624	int segmentCount = path.segmentCount();	1609	int segmentCount = path.segmentCount();
1625	switch (segmentCount) {	1610	if (segmentCount == 0) {
1626	case 0:	1611	return null;
1627	return null;	1612	}
1628	case 1:	1613	if (path.getDevice() != null \|\| JavaModel.getExternalTarget(path, true/check existence/) != null) {
1629	if (path.equals(getPath())) { // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=75814	1614	// external path
1630	// default root	1615	return getPackageFragmentRoot0(path);
1631	return getPackageFragmentRoot(this.project);	1616	}
1632	}	1617	IWorkspaceRoot workspaceRoot = this.project.getWorkspace().getRoot();
1633	default:	1618	if (segmentCount == 1) {
1634	// a path ending with .jar/.zip is still ambiguous and could still resolve to a source/lib folder	1619	String projectName = path.segment(0);
1635	// thus will try to guess based on existing resource	1620	if (getElementName().equals(projectName)) { // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=75814
1636	if (org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(path.lastSegment())) {	1621	// default root
1637	IResource resource = this.project.getWorkspace().getRoot().findMember(path);	1622	return getPackageFragmentRoot(this.project);
1638	if (resource != null && resource.getType() == IResource.FOLDER){	1623	} else {
1639	return getPackageFragmentRoot(resource);	1624	// lib being another project
1640	}	1625	return getPackageFragmentRoot(workspaceRoot.getProject(projectName));
1641	return getPackageFragmentRoot0(path);	1626	}
1642	} else if (segmentCount == 1) {	1627	}
1643	// lib being another project	1628	IResource resource = workspaceRoot.findMember(path);
1644	return getPackageFragmentRoot(this.project.getWorkspace().getRoot().getProject(path.lastSegment()));	1629	if (resource == null) {
1645	} else {	1630	// resource doesn't exist in workspace
1646	// lib being a folder	1631	if (path.getFileExtension() != null) {
1647	return getPackageFragmentRoot(this.project.getWorkspace().getRoot().getFolder(path));	1632	// assume it is a file
1648	}	1633	resource = workspaceRoot.getFile(path);
		1634	} else {
		1635	// assume it is a folder
		1636	resource = workspaceRoot.getFolder(path);
		1637	}
1649	}	1638	}
		1639	return getPackageFragmentRoot(resource);
1650	}	1640	}
1651		1641
1652	/**	1642	/**
Lines 1659-1669 Link Here
1659	private IPackageFragmentRoot getPackageFragmentRoot(IResource resource, IPath entryPath) {	1649	private IPackageFragmentRoot getPackageFragmentRoot(IResource resource, IPath entryPath) {
1660	switch (resource.getType()) {	1650	switch (resource.getType()) {
1661	case IResource.FILE:	1651	case IResource.FILE:
1662	if (org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(resource.getName())) {	1652	return new JarPackageFragmentRoot(resource, this);
1663	return new JarPackageFragmentRoot(resource, this);
1664	} else {
1665	return null;
1666	}
1667	case IResource.FOLDER:	1653	case IResource.FOLDER:
1668	if (ExternalFoldersManager.isInternalPathForExternalFolder(resource.getFullPath()))	1654	if (ExternalFoldersManager.isInternalPathForExternalFolder(resource.getFullPath()))
1669	return new ExternalPackageFragmentRoot(resource, entryPath, this);	1655	return new ExternalPackageFragmentRoot(resource, entryPath, this);
Lines 1679-1685 Link Here
1679	* @see IJavaProject	1665	* @see IJavaProject
1680	*/	1666	*/
1681	public IPackageFragmentRoot getPackageFragmentRoot(String libraryPath) {	1667	public IPackageFragmentRoot getPackageFragmentRoot(String libraryPath) {
1682
1683	return getPackageFragmentRoot0(JavaProject.canonicalizedPath(new Path(libraryPath)));	1668	return getPackageFragmentRoot0(JavaProject.canonicalizedPath(new Path(libraryPath)));
1684	}	1669	}
1685		1670
Lines 1687-1696 Link Here
1687	* no path canonicalization	1672	* no path canonicalization
1688	*/	1673	*/
1689	public IPackageFragmentRoot getPackageFragmentRoot0(IPath libraryPath) {	1674	public IPackageFragmentRoot getPackageFragmentRoot0(IPath libraryPath) {
1690	if (!org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(libraryPath.lastSegment()))	1675	IFolder linkedFolder = JavaModelManager.getExternalManager().getFolder(libraryPath);
1691	return new ExternalPackageFragmentRoot(libraryPath, this);	1676	if (linkedFolder != null)
		1677	return new ExternalPackageFragmentRoot(linkedFolder, libraryPath, this);
1692	return new JarPackageFragmentRoot(libraryPath, this);	1678	return new JarPackageFragmentRoot(libraryPath, this);
1693
1694	}	1679	}
1695		1680
1696	/**	1681	/**

Lines 715-723 Link Here

(-)src/org/eclipse/jdt/core/tests/model/TypeHierarchyTests.java (-4 / +36 lines)
715	"}",	715	"}",
716	},	716	},
717	new HashMap(),	717	new HashMap(),
718	getExternalFolderPath("externalLib"));	718	getExternalResourcePath("externalLib"));
719	createJavaProject("P", new String[0], new String[] {getExternalFolderPath("externalLib")}, "");	719	createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
720	IClassFile classFile = getClassFile("P", getExternalFolderPath("externalLib"), "p", "X.class");	720	IClassFile classFile = getClassFile("P", getExternalResourcePath("externalLib"), "p", "X.class");
721	ITypeHierarchy hierarchy = classFile.getType().newTypeHierarchy(null);	721	ITypeHierarchy hierarchy = classFile.getType().newTypeHierarchy(null);
722	assertHierarchyEquals(	722	assertHierarchyEquals(
723	"Focus: X [in X.class [in p [in "+ getExternalPath() + "externalLib]]]\n" +	723	"Focus: X [in X.class [in p [in "+ getExternalPath() + "externalLib]]]\n" +
Lines 727-733 Link Here
727	hierarchy);	727	hierarchy);
728	} finally {	728	} finally {
729	deleteProject("P");	729	deleteProject("P");
730	deleteExternalFolder("externalLib");	730	deleteExternalResource("externalLib");
		731	}
		732	}
		733	/*
		734	* Ensures that subtypes are found in an external ZIP archive
		735	*/
		736	public void testZIPArchive() throws CoreException, IOException {
		737	try {
		738	org.eclipse.jdt.core.tests.util.Util.createJar(
		739	new String[] {
		740	"p/X.java",
		741	"package p;\n" +
		742	"public class X {\n" +
		743	"}",
		744	"p/Y.java",
		745	"package p;\n" +
		746	"public class Y extends X {\n" +
		747	"}",
		748	},
		749	getExternalResourcePath("externalLib.abc"),
		750	"1.4");
		751	createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		752	IClassFile classFile = getClassFile("P", getExternalResourcePath("externalLib.abc"), "p", "X.class");
		753	ITypeHierarchy hierarchy = classFile.getType().newTypeHierarchy(null);
		754	assertHierarchyEquals(
		755	"Focus: X [in X.class [in p [in "+ getExternalPath() + "externalLib.abc]]]\n" +
		756	"Super types:\n" +
		757	"Sub types:\n" +
		758	" Y [in Y.class [in p [in "+ getExternalPath() + "externalLib.abc]]]\n",
		759	hierarchy);
		760	} finally {
		761	deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		762	deleteProject("P");
731	}	763	}
732	}	764	}
733	/*	765	/*

Lines 11-17 Link Here

(-)model/org/eclipse/jdt/core/WorkingCopyOwner.java (-3 / +2 lines)
11	package org.eclipse.jdt.core;	11	package org.eclipse.jdt.core;
12		12
13	import org.eclipse.core.runtime.IProgressMonitor;	13	import org.eclipse.core.runtime.IProgressMonitor;
14	import org.eclipse.core.runtime.Path;
15	import org.eclipse.jdt.internal.core.BufferManager;	14	import org.eclipse.jdt.internal.core.BufferManager;
16	import org.eclipse.jdt.internal.core.CompilationUnit;	15	import org.eclipse.jdt.internal.core.CompilationUnit;
17	import org.eclipse.jdt.internal.core.DefaultWorkingCopyOwner;	16	import org.eclipse.jdt.internal.core.DefaultWorkingCopyOwner;
Lines 135-141 Link Here
135	*/	134	*/
136	public final ICompilationUnit newWorkingCopy(String name, IClasspathEntry[] classpath, IProblemRequestor problemRequestor, IProgressMonitor monitor) throws JavaModelException {	135	public final ICompilationUnit newWorkingCopy(String name, IClasspathEntry[] classpath, IProblemRequestor problemRequestor, IProgressMonitor monitor) throws JavaModelException {
137	ExternalJavaProject project = new ExternalJavaProject(classpath);	136	ExternalJavaProject project = new ExternalJavaProject(classpath);
138	IPackageFragment parent = project.getPackageFragmentRoot(Path.EMPTY).getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME);	137	IPackageFragment parent = project.getPackageFragmentRoot(project.getProject()).getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME);
139	CompilationUnit result = new CompilationUnit((PackageFragment) parent, name, this);	138	CompilationUnit result = new CompilationUnit((PackageFragment) parent, name, this);
140	result.becomeWorkingCopy(problemRequestor, monitor);	139	result.becomeWorkingCopy(problemRequestor, monitor);
141	return result;	140	return result;
Lines 182-188 Link Here
182	*/	181	*/
183	public final ICompilationUnit newWorkingCopy(String name, IClasspathEntry[] classpath, IProgressMonitor monitor) throws JavaModelException {	182	public final ICompilationUnit newWorkingCopy(String name, IClasspathEntry[] classpath, IProgressMonitor monitor) throws JavaModelException {
184	ExternalJavaProject project = new ExternalJavaProject(classpath);	183	ExternalJavaProject project = new ExternalJavaProject(classpath);
185	IPackageFragment parent = project.getPackageFragmentRoot(Path.EMPTY).getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME);	184	IPackageFragment parent = project.getPackageFragmentRoot(project.getProject()).getPackageFragment(IPackageFragment.DEFAULT_PACKAGE_NAME);
186	CompilationUnit result = new CompilationUnit((PackageFragment) parent, name, this);	185	CompilationUnit result = new CompilationUnit((PackageFragment) parent, name, this);
187	result.becomeWorkingCopy(getProblemRequestor(result), monitor);	186	result.becomeWorkingCopy(getProblemRequestor(result), monitor);
188	return result;	187	return result;

Lines 473-480 Link Here

(-)model/org/eclipse/jdt/core/IJavaProject.java (-4 / +5 lines)
473	IPath getOutputLocation() throws JavaModelException;	473	IPath getOutputLocation() throws JavaModelException;
474		474
475	/**	475	/**
476	* Returns a package fragment root for an external library (a JAR or - since 3.4 - a class folder)	476	* Returns a package fragment root for an external library
477	* at the specified file system path.	477	* (a ZIP archive - e.g. a <code>.jar</code>, a <code>.zip</code> file, etc. -
		478	* or - since 3.4 - a class folder) at the specified file system path.
478	* This is a handle-only method. The underlying <code>java.io.File</code>	479	* This is a handle-only method. The underlying <code>java.io.File</code>
479	* may or may not exist. No resource is associated with this local library	480	* may or may not exist. No resource is associated with this local library
480	* package fragment root.	481	* package fragment root.
Lines 487-499 Link Here
487	/**	488	/**
488	* Returns a package fragment root for the given resource, which	489	* Returns a package fragment root for the given resource, which
489	* must either be a folder representing the top of a package hierarchy,	490	* must either be a folder representing the top of a package hierarchy,
490	* or a <code>.jar</code> or <code>.zip</code> file.	491	* or a ZIP archive (e.g. a <code>.jar</code>, a <code>.zip</code> file, etc.)
491	* This is a handle-only method. The underlying resource may or may not exist.	492	* This is a handle-only method. The underlying resource may or may not exist.
492	*	493	*
493	* @param resource the given resource	494	* @param resource the given resource
494	* @return a package fragment root for the given resource, which	495	* @return a package fragment root for the given resource, which
495	* must either be a folder representing the top of a package hierarchy,	496	* must either be a folder representing the top of a package hierarchy,
496	* or a <code>.jar</code> or <code>.zip</code> file	497	* or a ZIP archive (e.g. a <code>.jar</code>, a <code>.zip</code> file, etc.)
497	*/	498	*/
498	IPackageFragmentRoot getPackageFragmentRoot(IResource resource);	499	IPackageFragmentRoot getPackageFragmentRoot(IResource resource);
499		500

Lines 127-133 Link Here

(-)model/org/eclipse/jdt/core/JavaCore.java (-28 / +19 lines)
127	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;	127	import org.eclipse.jdt.internal.compiler.classfmt.ClassFileConstants;
128	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;	128	import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
129	import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;	129	import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
130	import org.eclipse.jdt.internal.compiler.util.SuffixConstants;
131	import org.eclipse.jdt.internal.core.*;	130	import org.eclipse.jdt.internal.core.*;
132	import org.eclipse.jdt.internal.core.builder.JavaBuilder;	131	import org.eclipse.jdt.internal.core.builder.JavaBuilder;
133	import org.eclipse.jdt.internal.core.builder.State;	132	import org.eclipse.jdt.internal.core.builder.State;
Lines 2363-2369 Link Here
2363	* <li>a file with one of the {@link JavaCore#getJavaLikeExtensions()	2362	* <li>a file with one of the {@link JavaCore#getJavaLikeExtensions()
2364	* Java-like extensions} - the element returned is the corresponding <code>ICompilationUnit</code></li>	2363	* Java-like extensions} - the element returned is the corresponding <code>ICompilationUnit</code></li>
2365	* <li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li>	2364	* <li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li>
2366	* <li>a <code>.jar</code> file - the element returned is the corresponding <code>IPackageFragmentRoot</code></li>	2365	* <li>a ZIP archive (e.g. a <code>.jar</code>, a <code>.zip</code> file, etc.) - the element returned is the corresponding <code>IPackageFragmentRoot</code></li>
2367	* </ul>	2366	* </ul>
2368	* <p>	2367	* <p>
2369	* Creating a Java element has the side effect of creating and opening all of the	2368	* Creating a Java element has the side effect of creating and opening all of the
Lines 2421-2427 Link Here
2421	* <li>a file with one of the {@link JavaCore#getJavaLikeExtensions()	2420	* <li>a file with one of the {@link JavaCore#getJavaLikeExtensions()
2422	* Java-like extensions} - the element returned is the corresponding <code>ICompilationUnit</code></li>	2421	* Java-like extensions} - the element returned is the corresponding <code>ICompilationUnit</code></li>
2423	* <li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li>	2422	* <li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li>
2424	* <li>a <code>.jar</code> file - the element returned is the corresponding <code>IPackageFragmentRoot</code></li>	2423	* <li>a ZIP archive (e.g. a <code>.jar</code>, a <code>.zip</code> file, etc.) - the element returned is the corresponding <code>IPackageFragmentRoot</code></li>
2425	* <li>a folder - the element returned is the corresponding <code>IPackageFragmentRoot</code>	2424	* <li>a folder - the element returned is the corresponding <code>IPackageFragmentRoot</code>
2426	* or <code>IPackageFragment</code></li>	2425	* or <code>IPackageFragment</code></li>
2427	* <li>the workspace root resource - the element returned is the <code>IJavaModel</code></li>	2426	* <li>the workspace root resource - the element returned is the <code>IJavaModel</code></li>
Lines 2448-2454 Link Here
2448	* <li>a file with one of the {@link JavaCore#getJavaLikeExtensions()	2447	* <li>a file with one of the {@link JavaCore#getJavaLikeExtensions()
2449	* Java-like extensions} - the element returned is the corresponding <code>ICompilationUnit</code></li>	2448	* Java-like extensions} - the element returned is the corresponding <code>ICompilationUnit</code></li>
2450	* <li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li>	2449	* <li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li>
2451	* <li>a <code>.jar</code> file - the element returned is the corresponding <code>IPackageFragmentRoot</code></li>	2450	* <li>a ZIP archive (e.g. a <code>.jar</code>, a <code>.zip</code> file, etc.) - the element returned is the corresponding <code>IPackageFragmentRoot</code></li>
2452	* <li>a folder - the element returned is the corresponding <code>IPackageFragmentRoot</code>	2451	* <li>a folder - the element returned is the corresponding <code>IPackageFragmentRoot</code>
2453	* or <code>IPackageFragment</code></li>	2452	* or <code>IPackageFragment</code></li>
2454	* <li>the workspace root resource - the element returned is the <code>IJavaModel</code></li>	2453	* <li>the workspace root resource - the element returned is the <code>IJavaModel</code></li>
Lines 3231-3250 Link Here
3231	entry.getExtraAttributes(),	3230	entry.getExtraAttributes(),
3232	entry.isExported());	3231	entry.isExported());
3233	case IResource.FILE :	3232	case IResource.FILE :
3234	if (org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(resolvedResource.getName())) {	3233	// internal binary archive
3235	// internal binary archive
3236	return JavaCore.newLibraryEntry(
3237	resolvedPath,
3238	getResolvedVariablePath(entry.getSourceAttachmentPath()),
3239	getResolvedVariablePath(entry.getSourceAttachmentRootPath()),
3240	entry.getAccessRules(),
3241	entry.getExtraAttributes(),
3242	entry.isExported());
3243	}
3244	break;
3245
3246	case IResource.FOLDER :
3247	// internal binary folder
3248	return JavaCore.newLibraryEntry(	3234	return JavaCore.newLibraryEntry(
3249	resolvedPath,	3235	resolvedPath,
3250	getResolvedVariablePath(entry.getSourceAttachmentPath()),	3236	getResolvedVariablePath(entry.getSourceAttachmentPath()),
Lines 3252-3266 Link Here
3252	entry.getAccessRules(),	3238	entry.getAccessRules(),
3253	entry.getExtraAttributes(),	3239	entry.getExtraAttributes(),
3254	entry.isExported());	3240	entry.isExported());
3255	}	3241	case IResource.FOLDER :
3256	}	3242	// internal binary folder
3257	if (target instanceof File) {
3258	File externalFile = JavaModel.getFile(target);
3259	if (externalFile != null) {
3260	// outside the workspace
3261	String fileName = externalFile.getName().toLowerCase();
3262	if (fileName.endsWith(SuffixConstants.SUFFIX_STRING_jar) \|\| fileName.endsWith(SuffixConstants.SUFFIX_STRING_zip)) {
3263	// external binary archive
3264	return JavaCore.newLibraryEntry(	3243	return JavaCore.newLibraryEntry(
3265	resolvedPath,	3244	resolvedPath,
3266	getResolvedVariablePath(entry.getSourceAttachmentPath()),	3245	getResolvedVariablePath(entry.getSourceAttachmentPath()),
Lines 3268-3274 Link Here
3268	entry.getAccessRules(),	3247	entry.getAccessRules(),
3269	entry.getExtraAttributes(),	3248	entry.getExtraAttributes(),
3270	entry.isExported());	3249	entry.isExported());
3271	}	3250	}
		3251	}
		3252	if (target instanceof File) {
		3253	File externalFile = JavaModel.getFile(target);
		3254	if (externalFile != null) {
		3255	// external binary archive
		3256	return JavaCore.newLibraryEntry(
		3257	resolvedPath,
		3258	getResolvedVariablePath(entry.getSourceAttachmentPath()),
		3259	getResolvedVariablePath(entry.getSourceAttachmentRootPath()),
		3260	entry.getAccessRules(),
		3261	entry.getExtraAttributes(),
		3262	entry.isExported());
3272	} else {	3263	} else {
3273	// non-existing file	3264	// non-existing file
3274	if (resolvedPath.isAbsolute()){	3265	if (resolvedPath.isAbsolute()){

Lines 25-31 Link Here

(-)model/org/eclipse/jdt/core/JavaConventions.java (-9 lines)
25	import org.eclipse.jdt.internal.compiler.parser.Scanner;	25	import org.eclipse.jdt.internal.compiler.parser.Scanner;
26	import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;	26	import org.eclipse.jdt.internal.compiler.parser.ScannerHelper;
27	import org.eclipse.jdt.internal.compiler.parser.TerminalTokens;	27	import org.eclipse.jdt.internal.compiler.parser.TerminalTokens;
28	import org.eclipse.jdt.internal.compiler.util.SuffixConstants;
29	import org.eclipse.jdt.internal.core.*;	28	import org.eclipse.jdt.internal.core.*;
30	import org.eclipse.jdt.internal.core.util.Messages;	29	import org.eclipse.jdt.internal.core.util.Messages;
31		30
Lines 62-75 Link Here
62	if (rootPath1 == null \|\| rootPath2 == null) {	61	if (rootPath1 == null \|\| rootPath2 == null) {
63	return false;	62	return false;
64	}	63	}
65	String extension1 = rootPath1.getFileExtension();
66	String extension2 = rootPath2.getFileExtension();
67	if (extension1 != null && (extension1.equalsIgnoreCase(SuffixConstants.EXTENSION_JAR) \|\| extension1.equalsIgnoreCase(SuffixConstants.EXTENSION_ZIP))) {
68	return false;
69	}
70	if (extension2 != null && (extension2.equalsIgnoreCase(SuffixConstants.EXTENSION_JAR) \|\| extension2.equalsIgnoreCase(SuffixConstants.EXTENSION_ZIP))) {
71	return false;
72	}
73	return rootPath1.isPrefixOf(rootPath2) \|\| rootPath2.isPrefixOf(rootPath1);	64	return rootPath1.isPrefixOf(rootPath2) \|\| rootPath2.isPrefixOf(rootPath1);
74	}	65	}
75		66

Lines 38-47 Link Here

(-)model/org/eclipse/jdt/internal/core/PackageFragmentRoot.java (-46 / +14 lines)
38	public final static String NO_SOURCE_ATTACHMENT = ""; //$NON-NLS-1$	38	public final static String NO_SOURCE_ATTACHMENT = ""; //$NON-NLS-1$
39		39
40	/**	40	/**
41	* The resource associated with this root.	41	* The resource associated with this root (null for external jar)
42	* (an IResource or a java.io.File (for external jar only))
43	*/	42	*/
44	protected Object resource;	43	protected IResource resource;
45		44
46	/**	45	/**
47	* Constructs a package fragment root which is the root of the java package	46	* Constructs a package fragment root which is the root of the java package
Lines 335-361 Link Here
335	JavaProject parentProject = (JavaProject) getJavaProject();	334	JavaProject parentProject = (JavaProject) getJavaProject();
336	try {	335	try {
337	entry = parentProject.getClasspathEntryFor(rootPath);	336	entry = parentProject.getClasspathEntryFor(rootPath);
338	if (entry != null){	337	if (entry != null) {
339	Object target = JavaModel.getTarget(entry.getSourceAttachmentPath(), true);	338	Object target = JavaModel.getTarget(entry.getSourceAttachmentPath(), true);
340	if (target instanceof IResource) {	339	if (target != null) {
341	if (target instanceof IFile) {	340	return entry;
342	IFile file = (IFile) target;
343	if (org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(file.getName())){
344	return entry;
345	}
346	} else if (target instanceof IContainer) {
347	return entry;
348	}
349	} else if (target instanceof java.io.File){
350	java.io.File file = JavaModel.getFile(target);
351	if (file != null) {
352	if (org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(file.getName())){
353	return entry;
354	}
355	} else {
356	// external directory
357	return entry;
358	}
359	}	341	}
360	}	342	}
361	} catch(JavaModelException e){	343	} catch(JavaModelException e){
Lines 372-391 Link Here
372	entry = jProject.getClasspathEntryFor(rootPath);	354	entry = jProject.getClasspathEntryFor(rootPath);
373	if (entry != null){	355	if (entry != null){
374	Object target = JavaModel.getTarget(entry.getSourceAttachmentPath(), true);	356	Object target = JavaModel.getTarget(entry.getSourceAttachmentPath(), true);
375	if (target instanceof IResource) {	357	if (target != null) {
376	if (target instanceof IFile){	358	return entry;
377	IFile file = (IFile) target;
378	if (org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(file.getName())){
379	return entry;
380	}
381	} else if (target instanceof IContainer) {
382	return entry;
383	}
384	} else if (target instanceof java.io.File){
385	java.io.File file = (java.io.File) target;
386	if (org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(file.getName())){
387	return entry;
388	}
389	}	359	}
390	}	360	}
391	} catch(JavaModelException e){	361	} catch(JavaModelException e){
Lines 587-601 Link Here
587		557
588		558
589	public IResource resource() {	559	public IResource resource() {
590	if (this.resource instanceof IResource) // perf improvement to avoid message send in resource()	560	if (this.resource != null) // perf improvement to avoid message send in resource()
591	return (IResource) this.resource;	561	return this.resource;
592	return super.resource();	562	return super.resource();
593	}	563	}
594	/*	564	/*
595	* @see IJavaElement	565	* @see IJavaElement
596	*/	566	*/
597	public IResource resource(PackageFragmentRoot root) {	567	public IResource resource(PackageFragmentRoot root) {
598	return (IResource)this.resource;	568	return this.resource;
599	}	569	}
600		570
601	/**	571	/**
Lines 776-793 Link Here
776	protected void toStringInfo(int tab, StringBuffer buffer, Object info, boolean showResolvedInfo) {	746	protected void toStringInfo(int tab, StringBuffer buffer, Object info, boolean showResolvedInfo) {
777	buffer.append(this.tabString(tab));	747	buffer.append(this.tabString(tab));
778	IPath path = getPath();	748	IPath path = getPath();
779	if (getJavaProject().getElementName().equals(path.segment(0))) {	749	if (isExternal()) {
		750	buffer.append(path.toOSString());
		751	} else if (getJavaProject().getElementName().equals(path.segment(0))) {
780	if (path.segmentCount() == 1) {	752	if (path.segmentCount() == 1) {
781	buffer.append("<project root>"); //$NON-NLS-1$	753	buffer.append("<project root>"); //$NON-NLS-1$
782	} else {	754	} else {
783	buffer.append(path.removeFirstSegments(1).makeRelative());	755	buffer.append(path.removeFirstSegments(1).makeRelative());
784	}	756	}
785	} else {	757	} else {
786	if (isExternal()) {	758	buffer.append(path);
787	buffer.append(path.toOSString());
788	} else {
789	buffer.append(path);
790	}
791	}	759	}
792	if (info == null) {	760	if (info == null) {
793	buffer.append(" (not open)"); //$NON-NLS-1$	761	buffer.append(" (not open)"); //$NON-NLS-1$

Lines 19-24 Link Here

(-)model/org/eclipse/jdt/internal/core/ClasspathEntry.java (-14 / +10 lines)
19	import java.util.HashSet;	19	import java.util.HashSet;
20	import java.util.Map;	20	import java.util.Map;
21		21
		22	import org.eclipse.core.resources.IContainer;
22	import org.eclipse.core.resources.IProject;	23	import org.eclipse.core.resources.IProject;
23	import org.eclipse.core.resources.IResource;	24	import org.eclipse.core.resources.IResource;
24	import org.eclipse.core.resources.IWorkspaceRoot;	25	import org.eclipse.core.resources.IWorkspaceRoot;
Lines 1375-1381 Link Here
1375	break;	1376	break;
1376		1377
1377	case IClasspathEntry.CPE_LIBRARY:	1378	case IClasspathEntry.CPE_LIBRARY:
1378	hasLibFolder \|= !org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(path.lastSegment());	1379	Object target = JavaModel.getTarget(path, false/don't check resource existence/);
		1380	hasLibFolder \|= target instanceof IContainer;
1379	if ((index = Util.indexOfMatchingPath(path, outputLocations, outputCount)) != -1){	1381	if ((index = Util.indexOfMatchingPath(path, outputLocations, outputCount)) != -1){
1380	allowNestingInOutputLocations[index] = true;	1382	allowNestingInOutputLocations[index] = true;
1381	}	1383	}
Lines 1415-1421 Link Here
1415		1417
1416	// allow nesting source entries in each other as long as the outer entry excludes the inner one	1418	// allow nesting source entries in each other as long as the outer entry excludes the inner one
1417	if (kind == IClasspathEntry.CPE_SOURCE	1419	if (kind == IClasspathEntry.CPE_SOURCE
1418	\|\| (kind == IClasspathEntry.CPE_LIBRARY && !org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(entryPath.lastSegment()))){	1420	\|\| (kind == IClasspathEntry.CPE_LIBRARY && (JavaModel.getTarget(entryPath, false/don't check existence/) instanceof IContainer))) {
1419	for (int j = 0; j < classpath.length; j++){	1421	for (int j = 0; j < classpath.length; j++){
1420	IClasspathEntry otherEntry = classpath[j];	1422	IClasspathEntry otherEntry = classpath[j];
1421	if (otherEntry == null) continue;	1423	if (otherEntry == null) continue;
Lines 1424-1430 Link Here
1424	if (entry != otherEntry	1426	if (entry != otherEntry
1425	&& (otherKind == IClasspathEntry.CPE_SOURCE	1427	&& (otherKind == IClasspathEntry.CPE_SOURCE
1426	\|\| (otherKind == IClasspathEntry.CPE_LIBRARY	1428	\|\| (otherKind == IClasspathEntry.CPE_LIBRARY
1427	&& !org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(otherPath.lastSegment())))){	1429	&& (JavaModel.getTarget(otherPath, false/don't check existence/) instanceof IContainer)))) {
1428	char[][] inclusionPatterns, exclusionPatterns;	1430	char[][] inclusionPatterns, exclusionPatterns;
1429	if (otherPath.isPrefixOf(entryPath)	1431	if (otherPath.isPrefixOf(entryPath)
1430	&& !otherPath.equals(entryPath)	1432	&& !otherPath.equals(entryPath)
Lines 1636-1650 Link Here
1636	IResource resolvedResource = (IResource) target;	1638	IResource resolvedResource = (IResource) target;
1637	switch(resolvedResource.getType()){	1639	switch(resolvedResource.getType()){
1638	case IResource.FILE :	1640	case IResource.FILE :
1639	if (org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(resolvedResource.getName())) {	1641	if (checkSourceAttachment
1640	if (checkSourceAttachment	1642	&& sourceAttachment != null
1641	&& sourceAttachment != null	1643	&& !sourceAttachment.isEmpty()
1642	&& !sourceAttachment.isEmpty()	1644	&& JavaModel.getTarget(sourceAttachment, true) == null){
1643	&& JavaModel.getTarget(sourceAttachment, true) == null){	1645	return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Messages.bind(Messages.classpath_unboundSourceAttachment, new String [] {sourceAttachment.toString(), path.toString(), projectName}));
1644	return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Messages.bind(Messages.classpath_unboundSourceAttachment, new String [] {sourceAttachment.toString(), path.toString(), projectName}));
1645	}
1646	} else {
1647	return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Messages.bind(Messages.classpath_illegalLibraryArchive, new String[] {entryPathMsg, projectName}));
1648	}	1646	}
1649	break;	1647	break;
1650	case IResource.FOLDER : // internal binary folder	1648	case IResource.FOLDER : // internal binary folder
Lines 1659-1666 Link Here
1659	File file = JavaModel.getFile(target);	1657	File file = JavaModel.getFile(target);
1660	if (file == null) {	1658	if (file == null) {
1661	return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Messages.bind(Messages.classpath_illegalExternalFolder, new String[] {path.toOSString(), projectName}));	1659	return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Messages.bind(Messages.classpath_illegalExternalFolder, new String[] {path.toOSString(), projectName}));
1662	} else if (!org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(file.getName())) {
1663	return new JavaModelStatus(IJavaModelStatusConstants.INVALID_CLASSPATH, Messages.bind(Messages.classpath_illegalLibraryArchive, (new String[] {path.toOSString(), projectName})));
1664	} else if (checkSourceAttachment	1660	} else if (checkSourceAttachment
1665	&& sourceAttachment != null	1661	&& sourceAttachment != null
1666	&& !sourceAttachment.isEmpty()	1662	&& !sourceAttachment.isEmpty()

Lines 12-17 Link Here

(-)model/org/eclipse/jdt/internal/core/JarPackageFragmentRoot.java (-30 / +36 lines)
12		12
13	import java.util.*;	13	import java.util.*;
14	import java.util.zip.ZipEntry;	14	import java.util.zip.ZipEntry;
		15	import java.util.zip.ZipException;
15	import java.util.zip.ZipFile;	16	import java.util.zip.ZipFile;
16		17
17	import org.eclipse.core.resources.IResource;	18	import org.eclipse.core.resources.IResource;
Lines 71-89 Link Here
71	IJavaElement[] children;	72	IJavaElement[] children;
72	ZipFile jar = null;	73	ZipFile jar = null;
73	try {	74	try {
74	// always create the default package
75	rawPackageInfo.put(CharOperation.NO_STRINGS, new ArrayList[] { EMPTY_LIST, EMPTY_LIST });
76
77	IJavaProject project = getJavaProject();	75	IJavaProject project = getJavaProject();
78	String sourceLevel = project.getOption(JavaCore.COMPILER_SOURCE, true);	76	String sourceLevel = project.getOption(JavaCore.COMPILER_SOURCE, true);
79	String compliance = project.getOption(JavaCore.COMPILER_COMPLIANCE, true);	77	String compliance = project.getOption(JavaCore.COMPILER_COMPLIANCE, true);
80	jar = getJar();	78	jar = getJar();
		79
		80	// always create the default package
		81	rawPackageInfo.put(CharOperation.NO_STRINGS, new ArrayList[] { EMPTY_LIST, EMPTY_LIST });
		82
81	for (Enumeration e= jar.entries(); e.hasMoreElements();) {	83	for (Enumeration e= jar.entries(); e.hasMoreElements();) {
82	ZipEntry member= (ZipEntry) e.nextElement();	84	ZipEntry member= (ZipEntry) e.nextElement();
83	initRawPackageInfo(rawPackageInfo, member.getName(), member.isDirectory(), sourceLevel, compliance);	85	initRawPackageInfo(rawPackageInfo, member.getName(), member.isDirectory(), sourceLevel, compliance);
84	}	86	}
85		87
86	//l oop through all of referenced packages, creating package fragments if necessary	88	// loop through all of referenced packages, creating package fragments if necessary
87	// and cache the entry names in the rawPackageInfo table	89	// and cache the entry names in the rawPackageInfo table
88	children = new IJavaElement[rawPackageInfo.size()];	90	children = new IJavaElement[rawPackageInfo.size()];
89	int index = 0;	91	int index = 0;
Lines 93-100 Link Here
93	children[index++] = getPackageFragment(pkgName);	95	children[index++] = getPackageFragment(pkgName);
94	}	96	}
95	} catch (CoreException e) {	97	} catch (CoreException e) {
96	if (e instanceof JavaModelException) throw (JavaModelException)e;	98	if (e.getCause() instanceof ZipException) {
97	throw new JavaModelException(e);	99	// not a ZIP archive, leave the children empty
		100	Util.log(e, "Invalid ZIP archive: " + toStringWithAncestors()); //$NON-NLS-1$
		101	children = NO_ELEMENTS;
		102	} else if (e instanceof JavaModelException) {
		103	throw (JavaModelException)e;
		104	} else {
		105	throw new JavaModelException(e);
		106	}
98	} finally {	107	} finally {
99	JavaModelManager.getJavaModelManager().closeZipFile(jar);	108	JavaModelManager.getJavaModelManager().closeZipFile(jar);
100	}	109	}
Lines 178-192 Link Here
178	}	187	}
179	}	188	}
180	public IResource resource(PackageFragmentRoot root) {	189	public IResource resource(PackageFragmentRoot root) {
181	if (this.resource == null && org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(this.jarPath.lastSegment())) {	190	if (this.resource == null) {
182	this.resource = JavaModel.getTarget(this.jarPath, false);
183	}
184	if (this.resource instanceof IResource) {
185	return super.resource(root);
186	} else {
187	// external jar	191	// external jar
188	return null;	192	return null;
189	}	193	}
		194	return super.resource(root);
190	}	195	}
191		196
192		197
Lines 266-288 Link Here
266	}	271	}
267		272
268	/**	273	/**
269	* Returns whether the corresponding resource or associated file exists	274	* Returns whether the corresponding resource or associated file exists
270	*/	275	*/
271	protected boolean resourceExists(IResource underlyingResource) {	276	protected boolean resourceExists(IResource underlyingResource) {
272	if (underlyingResource == null) {	277	if (underlyingResource == null) {
273	return	278	return
274	JavaModel.getTarget(	279	JavaModel.getExternalTarget(
275	getPath(), // don't make the path relative as this is an external archive	280	getPath()/don't make the path relative as this is an external archive/,
276	true) != null;	281	true/check existence/) != null;
277	} else {	282	} else {
278	return super.resourceExists(underlyingResource);	283	return super.resourceExists(underlyingResource);
		284	}
		285	}
		286
		287	protected void toStringAncestors(StringBuffer buffer) {
		288	if (isExternal())
		289	// don't show project as it is irrelevant for external jar files.
		290	// also see https://bugs.eclipse.org/bugs/show_bug.cgi?id=146615
		291	return;
		292	super.toStringAncestors(buffer);
279	}	293	}
280	}
281	protected void toStringAncestors(StringBuffer buffer) {
282	if (isExternal())
283	// don't show project as it is irrelevant for external jar files.
284	// also see https://bugs.eclipse.org/bugs/show_bug.cgi?id=146615
285	return;
286	super.toStringAncestors(buffer);
287	}
288	}	294	}

Lines 720-726 Link Here

(-)model/org/eclipse/jdt/internal/core/JavaModelManager.java (-4 / +3 lines)
720	* <li>a project - the element returned is the corresponding <code>IJavaProject</code></li>	720	* <li>a project - the element returned is the corresponding <code>IJavaProject</code></li>
721	* <li>a <code>.java</code> file - the element returned is the corresponding <code>ICompilationUnit</code></li>	721	* <li>a <code>.java</code> file - the element returned is the corresponding <code>ICompilationUnit</code></li>
722	* <li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li>	722	* <li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li>
723	* <li>a <code>.jar</code> file - the element returned is the corresponding <code>IPackageFragmentRoot</code></li>	723	* <li>a ZIP archive (e.g. a <code>.jar</code>, a <code>.zip</code> file, etc.) - the element returned is the corresponding <code>IPackageFragmentRoot</code></li>
724	* <li>a folder - the element returned is the corresponding <code>IPackageFragmentRoot</code>	724	* <li>a folder - the element returned is the corresponding <code>IPackageFragmentRoot</code>
725	* or <code>IPackageFragment</code></li>	725	* or <code>IPackageFragment</code></li>
726	* <li>the workspace root resource - the element returned is the <code>IJavaModel</code></li>	726	* <li>the workspace root resource - the element returned is the <code>IJavaModel</code></li>
Lines 757-763 Link Here
757	* <p>The file must be one of:<ul>	757	* <p>The file must be one of:<ul>
758	* <li>a <code>.java</code> file - the element returned is the corresponding <code>ICompilationUnit</code></li>	758	* <li>a <code>.java</code> file - the element returned is the corresponding <code>ICompilationUnit</code></li>
759	* <li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li>	759	* <li>a <code>.class</code> file - the element returned is the corresponding <code>IClassFile</code></li>
760	* <li>a <code>.jar</code> file - the element returned is the corresponding <code>IPackageFragmentRoot</code></li>	760	* <li>a ZIP archive (e.g. a <code>.jar</code>, a <code>.zip</code> file, etc.) - the element returned is the corresponding <code>IPackageFragmentRoot</code></li>
761	* </ul>	761	* </ul>
762	* <p>	762	* <p>
763	* Creating a Java element has the side effect of creating and opening all of the	763	* Creating a Java element has the side effect of creating and opening all of the
Lines 777-784 Link Here
777	return createCompilationUnitFrom(file, project);	777	return createCompilationUnitFrom(file, project);
778	if (org.eclipse.jdt.internal.compiler.util.Util.isClassFileName(name))	778	if (org.eclipse.jdt.internal.compiler.util.Util.isClassFileName(name))
779	return createClassFileFrom(file, project);	779	return createClassFileFrom(file, project);
780	if (org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(name))	780	return createJarPackageFragmentRootFrom(file, project);
781	return createJarPackageFragmentRootFrom(file, project);
782	}	781	}
783	return null;	782	return null;
784	}	783	}

Lines 472-478 Link Here

(-)batch/org/eclipse/jdt/internal/compiler/batch/Main.java (-8 / +3 lines)
472	File f = new File(classpath);	472	File f = new File(classpath);
473	String id = null;	473	String id = null;
474	if (f.isFile()) {	474	if (f.isFile()) {
475	if (Util.isArchiveFileName(classpath)) {	475	if (Util.isPotentialZipArchive(classpath)) {
476	id = Logger.CLASSPATH_JAR;	476	id = Logger.CLASSPATH_JAR;
477	} else {	477	} else {
478	id = Logger.CLASSPATH_FILE;	478	id = Logger.CLASSPATH_FILE;
Lines 1333-1343 Link Here
1333	public static File[][] getLibrariesFiles(File[] files) {	1333	public static File[][] getLibrariesFiles(File[] files) {
1334	FilenameFilter filter = new FilenameFilter() {	1334	FilenameFilter filter = new FilenameFilter() {
1335	public boolean accept(File dir, String name) {	1335	public boolean accept(File dir, String name) {
1336	String lowerCaseName = name.toLowerCase();	1336	return Util.isPotentialZipArchive(name);
1337	if (lowerCaseName.endsWith(SuffixConstants.SUFFIX_STRING_jar) \|\| lowerCaseName.endsWith(SuffixConstants.SUFFIX_STRING_zip)) {
1338	return true;
1339	}
1340	return false;
1341	}	1337	}
1342	};	1338	};
1343	final int filesLength = files.length;	1339	final int filesLength = files.length;
Lines 1494-1501 Link Here
1494	destPath = NONE; // keep == comparison valid	1490	destPath = NONE; // keep == comparison valid
1495	}	1491	}
1496	if (rejectDestinationPathOnJars && destPath != null &&	1492	if (rejectDestinationPathOnJars && destPath != null &&
1497	(currentClasspathName.endsWith(".jar") \|\| //$NON-NLS-1$	1493	Util.isPotentialZipArchive(currentClasspathName)) {
1498	currentClasspathName.endsWith(".zip"))) { //$NON-NLS-1$
1499	throw new InvalidInputException(	1494	throw new InvalidInputException(
1500	this.bind("configure.unexpectedDestinationPathEntryFile", //$NON-NLS-1$	1495	this.bind("configure.unexpectedDestinationPathEntryFile", //$NON-NLS-1$
1501	currentClasspathName));	1496	currentClasspathName));

Lines 115-132 Link Here

(-)batch/org/eclipse/jdt/internal/compiler/batch/messages.properties (-7 / +7 lines)
115	\ with ''+''.\n\	115	\ with ''+''.\n\
116	\ \n\	116	\ \n\
117	\ Classpath options:\n\	117	\ Classpath options:\n\
118	\ -cp -classpath <directories and zip/jar files separated by {0}>\n\	118	\ -cp -classpath <directories and ZIP archives separated by {0}>\n\
119	\ specify location for application classes and sources.\n\	119	\ specify location for application classes and sources.\n\
120	\ Each directory or file can specify access rules for\n\	120	\ Each directory or file can specify access rules for\n\
121	\ types between ''['' and '']'' (e.g. [-X] to forbid\n\	121	\ types between ''['' and '']'' (e.g. [-X] to forbid\n\
122	\ access to type X, [~X] to discourage access to type X,\n\	122	\ access to type X, [~X] to discourage access to type X,\n\
123	\ [+p/X{0}-p/*] to forbid access to all types in package p\n\	123	\ [+p/X{0}-p/*] to forbid access to all types in package p\n\
124	\ but allow access to p/X)\n\	124	\ but allow access to p/X)\n\
125	\ -bootclasspath <directories and zip/jar files separated by {0}>\n\	125	\ -bootclasspath <directories and ZIP archives separated by {0}>\n\
126	\ specify location for system classes. Each directory or\n\	126	\ specify location for system classes. Each directory or\n\
127	\ file can specify access rules for types between ''[''\n\	127	\ file can specify access rules for types between ''[''\n\
128	\ and '']''\n\	128	\ and '']''\n\
129	\ -sourcepath <directories and zip/jar files separated by {0}>\n\	129	\ -sourcepath <directories and ZIP archives separated by {0}>\n\
130	\ specify location for application sources. Each directory\n\	130	\ specify location for application sources. Each directory\n\
131	\ or file can specify access rules for types between ''[''\n\	131	\ or file can specify access rules for types between ''[''\n\
132	\ and '']''. Each directory can further specify a specific\n\	132	\ and '']''. Each directory can further specify a specific\n\
Lines 134-145 Link Here
134	\ and '']''; this overrides the general ''-d'' option.\n\	134	\ and '']''; this overrides the general ''-d'' option.\n\
135	\ .class files created from source files contained in a\n\	135	\ .class files created from source files contained in a\n\
136	\ jar file are put in the user.dir folder in case no\n\	136	\ jar file are put in the user.dir folder in case no\n\
137	\ general ''-d'' option is specified. zip/jar files cannot\n\	137	\ general ''-d'' option is specified. ZIP archives cannot\n\
138	\ override the general ''-d'' option\n\	138	\ override the general ''-d'' option\n\
139	\ -extdirs <directories separated by {0}>\n\	139	\ -extdirs <directories separated by {0}>\n\
140	\ specify location for extension zip/jar files\n\	140	\ specify location for extension ZIP archives\n\
141	\ -endorseddirs <directories separated by {0}>\n\	141	\ -endorseddirs <directories separated by {0}>\n\
142	\ specify location for endorsed zip/jar files\n\	142	\ specify location for endorsed ZIP archives\n\
143	\ -d <dir> destination directory (if omitted, no directory is\n\	143	\ -d <dir> destination directory (if omitted, no directory is\n\
144	\ created); this option can be overridden per source\n\	144	\ created); this option can be overridden per source\n\
145	\ directory\n\	145	\ directory\n\
Lines 175-181 Link Here
175	\ Annotation processing options:\n\	175	\ Annotation processing options:\n\
176	\ These options are meaningful only in a 1.6 environment.\n\	176	\ These options are meaningful only in a 1.6 environment.\n\
177	\ -Akey[=value] options that are passed to annotation processors\n\	177	\ -Akey[=value] options that are passed to annotation processors\n\
178	\ -processorpath <directories and zip/jar files separated by {0}>\n\	178	\ -processorpath <directories and ZIP archives separated by {0}>\n\
179	\ specify locations where to find annotation processors.\n\	179	\ specify locations where to find annotation processors.\n\
180	\ If this option is not used, the classpath will be\n\	180	\ If this option is not used, the classpath will be\n\
181	\ searched for processors\n\	181	\ searched for processors\n\

Lines 25-43 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/util/SuffixConstants.java (-15 lines)
25	public final static char[] SUFFIX_CLASS = SUFFIX_STRING_CLASS.toCharArray();	25	public final static char[] SUFFIX_CLASS = SUFFIX_STRING_CLASS.toCharArray();
26	public final static char[] SUFFIX_java = SUFFIX_STRING_java.toCharArray();	26	public final static char[] SUFFIX_java = SUFFIX_STRING_java.toCharArray();
27	public final static char[] SUFFIX_JAVA = SUFFIX_STRING_JAVA.toCharArray();	27	public final static char[] SUFFIX_JAVA = SUFFIX_STRING_JAVA.toCharArray();
28
29	public final static String EXTENSION_jar = "jar"; //$NON-NLS-1$
30	public final static String EXTENSION_JAR = "JAR"; //$NON-NLS-1$
31	public final static String EXTENSION_zip = "zip"; //$NON-NLS-1$
32	public final static String EXTENSION_ZIP = "ZIP"; //$NON-NLS-1$
33
34	public final static String SUFFIX_STRING_jar = "." + EXTENSION_jar; //$NON-NLS-1$
35	public final static String SUFFIX_STRING_JAR = "." + EXTENSION_JAR; //$NON-NLS-1$
36	public final static String SUFFIX_STRING_zip = "." + EXTENSION_zip; //$NON-NLS-1$
37	public final static String SUFFIX_STRING_ZIP = "." + EXTENSION_ZIP; //$NON-NLS-1$
38
39	public final static char[] SUFFIX_jar = SUFFIX_STRING_jar.toCharArray();
40	public final static char[] SUFFIX_JAR = SUFFIX_STRING_JAR.toCharArray();
41	public final static char[] SUFFIX_zip = SUFFIX_STRING_zip.toCharArray();
42	public final static char[] SUFFIX_ZIP = SUFFIX_STRING_ZIP.toCharArray();
43	}	28	}

Lines 470-503 Link Here

(-)compiler/org/eclipse/jdt/internal/compiler/util/Util.java (-23 / +29 lines)
470	}	470	}
471	}	471	}
472	}	472	}
		473
473	/**	474	/**
474	* Returns true iff str.toLowerCase().endsWith(".jar") \|\| str.toLowerCase().endsWith(".zip")	475	* Returns whether the given name is potentially a zip archive file name
475	* implementation is not creating extra strings.	476	* (it has a file extension and it is not ".java" nor ".class")
476	*/	477	*/
477	public final static boolean isArchiveFileName(String name) {	478	public final static boolean isPotentialZipArchive(String name) {
478	int nameLength = name == null ? 0 : name.length();	479	int lastDot = name.lastIndexOf('.');
479	int suffixLength = SUFFIX_JAR.length;	480	if (lastDot == -1)
480	if (nameLength < suffixLength) return false;	481	return false; // no file extension, it cannot be a zip archive name
481		482	if (name.lastIndexOf(File.separatorChar) > lastDot)
482	// try to match as JAR file	483	return false; // dot was before the last file separator, it cannot be a zip archive name
483	for (int i = 0; i < suffixLength; i++) {	484	int length = name.length();
484	char c = name.charAt(nameLength - i - 1);	485	int extensionLength = length - lastDot - 1;
485	int suffixIndex = suffixLength - i - 1;	486	if (extensionLength == EXTENSION_java.length()) {
486	if (c != SUFFIX_jar[suffixIndex] && c != SUFFIX_JAR[suffixIndex]) {	487	for (int i = extensionLength-1; i >=0; i--) {
487		488	if (Character.toLowerCase(name.charAt(length - extensionLength + i)) != EXTENSION_java.charAt(i)) {
488	// try to match as ZIP file	489	break; // not a ".java" file, check ".class" file case below
489	suffixLength = SUFFIX_ZIP.length;	490	}
490	if (nameLength < suffixLength) return false;	491	if (i == 0) {
491	for (int j = 0; j < suffixLength; j++) {	492	return false; // it is a ".java" file, it cannot be a zip archive name
492	c = name.charAt(nameLength - j - 1);
493	suffixIndex = suffixLength - j - 1;
494	if (c != SUFFIX_zip[suffixIndex] && c != SUFFIX_ZIP[suffixIndex]) return false;
495	}	493	}
496	return true;
497	}	494	}
498	}	495	}
499	return true;	496	if (extensionLength == EXTENSION_class.length()) {
500	}	497	for (int i = extensionLength-1; i >=0; i--) {
		498	if (Character.toLowerCase(name.charAt(length - extensionLength + i)) != EXTENSION_class.charAt(i)) {
		499	return true; // not a ".class" file, so this is a potential archive name
		500	}
		501	}
		502	return false; // it is a ".class" file, it cannot be a zip archive name
		503	}
		504	return true; // it is neither a ".java" file nor a ".class" file, so this is a potential archive name
		505	}
		506
501	/**	507	/**
502	* Returns true iff str.toLowerCase().endsWith(".class")	508	* Returns true iff str.toLowerCase().endsWith(".class")
503	* implementation is not creating extra strings.	509	* implementation is not creating extra strings.

Lines 161-168 Link Here

(-)model/org/eclipse/jdt/internal/core/builder/NameEnvironment.java (-4 lines)
161	IResource resource = (IResource) target;	161	IResource resource = (IResource) target;
162	ClasspathLocation bLocation = null;	162	ClasspathLocation bLocation = null;
163	if (resource instanceof IFile) {	163	if (resource instanceof IFile) {
164	if (!(org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(path.lastSegment())))
165	continue nextEntry;
166	AccessRuleSet accessRuleSet =	164	AccessRuleSet accessRuleSet =
167	(JavaCore.IGNORE.equals(javaProject.getOption(JavaCore.COMPILER_PB_FORBIDDEN_REFERENCE, true))	165	(JavaCore.IGNORE.equals(javaProject.getOption(JavaCore.COMPILER_PB_FORBIDDEN_REFERENCE, true))
168	&& JavaCore.IGNORE.equals(javaProject.getOption(JavaCore.COMPILER_PB_DISCOURAGED_REFERENCE, true)))	166	&& JavaCore.IGNORE.equals(javaProject.getOption(JavaCore.COMPILER_PB_DISCOURAGED_REFERENCE, true)))
Lines 191-198 Link Here
191	binaryLocationsPerProject.put(p, existingLocations);	189	binaryLocationsPerProject.put(p, existingLocations);
192	}	190	}
193	} else if (target instanceof File) {	191	} else if (target instanceof File) {
194	if (!(org.eclipse.jdt.internal.compiler.util.Util.isArchiveFileName(path.lastSegment())))
195	continue nextEntry;
196	AccessRuleSet accessRuleSet =	192	AccessRuleSet accessRuleSet =
197	(JavaCore.IGNORE.equals(javaProject.getOption(JavaCore.COMPILER_PB_FORBIDDEN_REFERENCE, true))	193	(JavaCore.IGNORE.equals(javaProject.getOption(JavaCore.COMPILER_PB_FORBIDDEN_REFERENCE, true))
198	&& JavaCore.IGNORE.equals(javaProject.getOption(JavaCore.COMPILER_PB_DISCOURAGED_REFERENCE, true)))	194	&& JavaCore.IGNORE.equals(javaProject.getOption(JavaCore.COMPILER_PB_DISCOURAGED_REFERENCE, true)))

Lines 490-496 Link Here

(-)src/org/eclipse/jdt/core/tests/model/ClasspathInitializerTests.java (-5 / +45 lines)
490	ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P3", "/P1"}) {	490	ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P3", "/P1"}) {
491	public void initialize(IPath containerPath, IJavaProject project) throws CoreException {	491	public void initialize(IPath containerPath, IJavaProject project) throws CoreException {
492	super.initialize(containerPath, project);	492	super.initialize(containerPath, project);
493	getJavaModel().refreshExternalArchives(new IJavaElement[] {p1}, null);	493	refreshExternalArchives(p1);
494	}	494	}
495	});	495	});
496	getWorkspace().run(new IWorkspaceRunnable() {	496	getWorkspace().run(new IWorkspaceRunnable() {
Lines 894-910 Link Here
894	try {	894	try {
895	createProject("P1");	895	createProject("P1");
896	createExternalFolder("externalLib");	896	createExternalFolder("externalLib");
897	ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", getExternalFolderPath("externalLib")}));	897	ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", getExternalResourcePath("externalLib")}));
898	IJavaProject p2 = createJavaProject(	898	IJavaProject p2 = createJavaProject(
899	"P2",	899	"P2",
900	new String[] {},	900	new String[] {},
901	new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},	901	new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
902	"");	902	"");
903	IPackageFragmentRoot root = p2.getPackageFragmentRoot(getExternalFolderPath("externalLib"));	903	IPackageFragmentRoot root = p2.getPackageFragmentRoot(getExternalResourcePath("externalLib"));
904	assertTrue(getExternalFolderPath("externalLib") + " should exist", root.exists());	904	assertTrue(getExternalResourcePath("externalLib") + " should exist", root.exists());
905	} finally {	905	} finally {
906	stopDeltas();	906	stopDeltas();
907	deleteExternalFolder("externalLib");	907	deleteExternalResource("externalLib");
		908	deleteProject("P1");
		909	deleteProject("P2");
		910	}
		911	}
		912
		913	public void testContainerInitializer22() throws CoreException {
		914	try {
		915	createProject("P1");
		916	createExternalFile("externalLib.abc", "");
		917	ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", getExternalResourcePath("externalLib.abc")}));
		918	IJavaProject p2 = createJavaProject(
		919	"P2",
		920	new String[] {},
		921	new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
		922	"");
		923	IPackageFragmentRoot root = p2.getPackageFragmentRoot(getExternalResourcePath("externalLib.abc"));
		924	assertTrue(getExternalResourcePath("externalLib.abc") + " should exist", root.exists());
		925	} finally {
		926	stopDeltas();
		927	deleteAndRefreshExternalZIPArchive("externalLib.abc", "P2");
		928	deleteProject("P1");
		929	deleteProject("P2");
		930	}
		931	}
		932
		933	public void testContainerInitializer23() throws CoreException {
		934	try {
		935	createProject("P1");
		936	IFile lib = createFile("/P1/internalLib.abc", "");
		937	ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", "/P1/internalLib.abc"}));
		938	IJavaProject p2 = createJavaProject(
		939	"P2",
		940	new String[] {},
		941	new String[] {"org.eclipse.jdt.core.tests.model.TEST_CONTAINER"},
		942	"");
		943	IPackageFragmentRoot root = p2.getPackageFragmentRoot(lib);
		944	assertTrue("/P1/internalLib.abc should exist", root.exists());
		945	} finally {
		946	stopDeltas();
		947	deleteAndRefreshExternalZIPArchive("externalLib.abc", "P2");
908	deleteProject("P1");	948	deleteProject("P1");
909	deleteProject("P2");	949	deleteProject("P2");
910	}	950	}

Lines 528-533 Link Here

(-)src/org/eclipse/jdt/core/tests/model/JavaSearchTests.java (-6 / +76 lines)
528	"",	528	"",
529	this.resultCollector);	529	this.resultCollector);
530	}	530	}
		531
531	/*	532	/*
532	* Ensures that a method declaration in an external library folder can be found	533	* Ensures that a method declaration in an external library folder can be found
533	*/	534	*/
Lines 544-552 Link Here
544	"}"	545	"}"
545	},	546	},
546	new HashMap(),	547	new HashMap(),
547	getExternalFolderPath("externalLib")	548	getExternalResourcePath("externalLib")
548	);	549	);
549	createJavaProject("P", new String[0], new String[] {getExternalFolderPath("externalLib")}, "");	550	createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
550	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaProject[] {getJavaProject("P")});	551	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaProject[] {getJavaProject("P")});
551	search("foo", METHOD, DECLARATIONS, scope);	552	search("foo", METHOD, DECLARATIONS, scope);
552	assertSearchResults(	553	assertSearchResults(
Lines 554-560 Link Here
554	this.resultCollector);	555	this.resultCollector);
555	} finally {	556	} finally {
556	deleteProject("P");	557	deleteProject("P");
557	deleteExternalFolder("externalLib");	558	deleteExternalResource("externalLib");
558	}	559	}
559	}	560	}
560		561
Lines 572-580 Link Here
572	"}"	573	"}"
573	},	574	},
574	new HashMap(),	575	new HashMap(),
575	getExternalFolderPath("externalLib")	576	getExternalResourcePath("externalLib")
576	);	577	);
577	createJavaProject("P", new String[0], new String[] {getExternalFolderPath("externalLib")}, "");	578	createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
578		579
579	TypeNameMatchCollector collector = new TypeNameMatchCollector();	580	TypeNameMatchCollector collector = new TypeNameMatchCollector();
580	new SearchEngine(this.workingCopies).searchAllTypeNames(	581	new SearchEngine(this.workingCopies).searchAllTypeNames(
Lines 594-603 Link Here
594	);	595	);
595	} finally {	596	} finally {
596	deleteProject("P");	597	deleteProject("P");
597	deleteExternalFolder("externalLib");	598	deleteExternalResource("externalLib");
598	}	599	}
599		600
600	}	601	}
		602
		603	/*
		604	* Ensures that a method declaration in an external ZIP archive can be found
		605	*/
		606	public void testZIPArchive1() throws Exception {
		607	try {
		608	org.eclipse.jdt.core.tests.util.Util.createJar(
		609	new String[] {
		610	"p/X.java",
		611	"package p;\n" +
		612	"public class X {\n" +
		613	" public void foo() {\n" +
		614	" }\n" +
		615	"}"
		616	},
		617	getExternalResourcePath("externalLib.abc"),
		618	"1.4");
		619	createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		620	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaProject[] {getJavaProject("P")});
		621	search("foo", METHOD, DECLARATIONS, scope);
		622	assertSearchResults(
		623	getExternalPath() + "externalLib.abc void p.X.foo()",
		624	this.resultCollector);
		625	} finally {
		626	deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
		627	deleteProject("P");
		628	}
		629	}
		630
		631	/*
		632	* Ensures that search all type names returns the types in an external ZIP archive
		633	*/
		634	public void testZIPArchive2() throws Exception {
		635	try {
		636	IJavaProject p = createJavaProject("P", new String[0], new String[] {getExternalResourcePath("externalLib.abc")}, "");
		637	org.eclipse.jdt.core.tests.util.Util.createJar(
		638	new String[] {
		639	"p/ExternalType.java",
		640	"package p;\n" +
		641	"public class ExternalType {\n" +
		642	"}"
		643	},
		644	getExternalResourcePath("externalLib.abc"),
		645	"1.4");
		646	refreshExternalArchives(p);
		647
		648	TypeNameMatchCollector collector = new TypeNameMatchCollector();
		649	new SearchEngine(this.workingCopies).searchAllTypeNames(
		650	null,
		651	SearchPattern.R_EXACT_MATCH,
		652	"ExternalType".toCharArray(),
		653	SearchPattern.R_EXACT_MATCH,
		654	TYPE,
		655	SearchEngine.createJavaSearchScope(new IJavaProject[] {getJavaProject("P")}),
		656	collector,
		657	IJavaSearchConstants.WAIT_UNTIL_READY_TO_SEARCH,
		658	null
		659	);
		660	assertSearchResults(
		661	"ExternalType (not open) [in ExternalType.class [in p [in "+ getExternalPath() + "externalLib.abc]]]",
		662	collector
		663	);
		664	} finally {
		665	deleteAndRefreshExternalZIPArchive("externalLib.abc", "P");
666	deleteProject("P");
667	}
668
669	}
670
601	/**	671	/**
602	* Simple field declaration test.	672	* Simple field declaration test.
603	*/	673	*/

Lines 16-21 Link Here

(-)src/org/eclipse/jdt/core/tests/model/ClassFileTests.java (-4 / +5 lines)
16	import org.eclipse.core.runtime.CoreException;	16	import org.eclipse.core.runtime.CoreException;
17	import org.eclipse.core.runtime.IPath;	17	import org.eclipse.core.runtime.IPath;
18	import org.eclipse.core.runtime.IProgressMonitor;	18	import org.eclipse.core.runtime.IProgressMonitor;
		19	import org.eclipse.core.runtime.Path;
19	import org.eclipse.jdt.core.*;	20	import org.eclipse.jdt.core.*;
20	import org.eclipse.jdt.core.search.IJavaSearchConstants;	21	import org.eclipse.jdt.core.search.IJavaSearchConstants;
21	import org.eclipse.jdt.core.search.IJavaSearchScope;	22	import org.eclipse.jdt.core.search.IJavaSearchScope;
Lines 790-803 Link Here
790	try {	791	try {
791	createExternalFolder("externalLib/p");	792	createExternalFolder("externalLib/p");
792	createExternalFile("externalLib/p/X.class", "");	793	createExternalFile("externalLib/p/X.class", "");
793	createJavaProject("P1", new String[0], new String[] {getExternalFolderPath("externalLib")}, "");	794	createJavaProject("P1", new String[0], new String[] {getExternalResourcePath("externalLib")}, "");
794	IClassFile classFile1 = getClassFile("P1", getExternalFolderPath("externalLib"), "p", "X.class");	795	IClassFile classFile1 = getClassFile("P1", getExternalResourcePath("externalLib"), "p", "X.class");
795	assertResourceEquals(	796	assertResourceEquals(
796	"Unexpected resource",	797	"Unexpected resource",
797	"<null>",	798	"<null>",
798	classFile1.getResource());	799	classFile1.getResource());
799	} finally {	800	} finally {
800	deleteExternalFolder("externalLib");	801	deleteExternalResource("externalLib");
801	deleteProject("P1");	802	deleteProject("P1");
802	}	803	}
803	}	804	}
Lines 852-858 Link Here
852	} catch (JavaModelException e) {	853	} catch (JavaModelException e) {
853	expected = e;	854	expected = e;
854	}	855	}
855	assertExceptionEquals("Unexpected exception", "classFolder.jar [in P1] does not exist", expected);	856	assertExceptionEquals("Unexpected exception", new Path("/P1/classFolder.jar").toOSString() + " does not exist", expected);
856	} finally {	857	} finally {
857	deleteProject("P1");	858	deleteProject("P1");
858	}	859	}

Lines 257-263 Link Here

(-)src/org/eclipse/jdt/core/tests/builder/TestingEnvironment.java (-6 / +2 lines)
257	public void addExternalJars(IPath projectPath, String[] jars, boolean isExported) throws JavaModelException {	257	public void addExternalJars(IPath projectPath, String[] jars, boolean isExported) throws JavaModelException {
258	for (int i = 0, max = jars.length; i < max; i++) {	258	for (int i = 0, max = jars.length; i < max; i++) {
259	String jar = jars[i];	259	String jar = jars[i];
260	checkAssertion("file name must end with .zip or .jar", jar.endsWith(".zip") \|\| jar.endsWith(".jar")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
261	addEntry(projectPath, JavaCore.newLibraryEntry(new Path(jar), null, null, isExported));	260	addEntry(projectPath, JavaCore.newLibraryEntry(new Path(jar), null, null, isExported));
262	}	261	}
263	}	262	}
Lines 265-271 Link Here
265	/** Adds an external jar to the classpath of a project.	264	/** Adds an external jar to the classpath of a project.
266	*/	265	*/
267	public void addExternalJar(IPath projectPath, String jar, boolean isExported) throws JavaModelException {	266	public void addExternalJar(IPath projectPath, String jar, boolean isExported) throws JavaModelException {
268	checkAssertion("file name must end with .zip or .jar", jar.endsWith(".zip") \|\| jar.endsWith(".jar")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
269	addEntry(projectPath, JavaCore.newLibraryEntry(new Path(jar), null, null, isExported));	267	addEntry(projectPath, JavaCore.newLibraryEntry(new Path(jar), null, null, isExported));
270	}	268	}
271		269
Lines 274-280 Link Here
274	addEntry(projectPath,	272	addEntry(projectPath,
275	JavaCore.newLibraryEntry(libraryPath, sourceAttachmentPath, sourceAttachmentRootPath));	273	JavaCore.newLibraryEntry(libraryPath, sourceAttachmentPath, sourceAttachmentRootPath));
276	}	274	}
277	private void addEntry(IPath projectPath, IClasspathEntry entryPath) throws JavaModelException {	275	public void addEntry(IPath projectPath, IClasspathEntry entryPath) throws JavaModelException {
278	IClasspathEntry[] classpath = getClasspath(projectPath);	276	IClasspathEntry[] classpath = getClasspath(projectPath);
279	IClasspathEntry[] newClaspath = new IClasspathEntry[classpath.length + 1];	277	IClasspathEntry[] newClaspath = new IClasspathEntry[classpath.length + 1];
280	System.arraycopy(classpath, 0, newClaspath, 0, classpath.length);	278	System.arraycopy(classpath, 0, newClaspath, 0, classpath.length);
Lines 311-323 Link Here
311		309
312	/** Adds a jar with the given contents to the the workspace.	310	/** Adds a jar with the given contents to the the workspace.
313	* If a jar with the same name already exists, it is	311	* If a jar with the same name already exists, it is
314	* replaced. A workspace must be open, and the given	312	* replaced. A workspace must be open. Returns the path of
315	* zip name must end with ".zip" or ".jar". Returns the path of
316	* the added jar.	313	* the added jar.
317	*/	314	*/
318	public IPath addInternalJar(IPath projectPath, String zipName, byte[] contents, boolean isExported) throws JavaModelException {	315	public IPath addInternalJar(IPath projectPath, String zipName, byte[] contents, boolean isExported) throws JavaModelException {
319	checkAssertion("a workspace must be open", fIsOpen); //$NON-NLS-1$	316	checkAssertion("a workspace must be open", fIsOpen); //$NON-NLS-1$
320	checkAssertion("zipName must end with .zip or .jar", zipName.endsWith(".zip") \|\| zipName.endsWith(".jar")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
321	IPath path = projectPath.append(zipName);	317	IPath path = projectPath.append(zipName);
322		318
323	/* remove any existing zip from the java model */	319	/* remove any existing zip from the java model */

Lines 259-265 Link Here

(-)src/org/eclipse/jdt/core/tests/builder/BuildpathTests.java (-1 / +128 lines)
259	}	259	}
260		260
261	/*	261	/*
262	* Ensures that the changing a type in an external folder and refreshing triggers a rebuild	262	* Ensures that changing a type in an external folder and refreshing triggers a rebuild
263	*/	263	*/
264	public void testChangeExternalFolder() throws CoreException {	264	public void testChangeExternalFolder() throws CoreException {
265	String externalLib = Util.getOutputDirectory() + File.separator + "externalLib";	265	String externalLib = Util.getOutputDirectory() + File.separator + "externalLib";
Lines 329-334 Link Here
329	}	329	}
330		330
331	/*	331	/*
		332	* Ensures that changing a type in an external ZIP archive and refreshing triggers a rebuild
		333	*/
		334	public void testChangeZIPArchive1() throws Exception {
		335	String externalLib = Util.getOutputDirectory() + File.separator + "externalLib.abc";
		336	try {
		337	org.eclipse.jdt.core.tests.util.Util.createJar(
		338	new String[] {
		339	"p/X.java",
		340	"package p;\n" +
		341	"public class X {\n" +
		342	" public void foo() {\n" +
		343	" }\n" +
		344	"}"
		345	},
		346	externalLib,
		347	"1.4");
		348
		349	IPath projectPath = env.addProject("Project");
		350	env.addExternalJars(projectPath, Util.getJavaClassLibs());
		351	env.addExternalJars(projectPath, new String[] {externalLib});
		352
		353	IPath root = env.getPackageFragmentRootPath(projectPath, ""); //$NON-NLS-1$
		354	env.setOutputFolder(projectPath, "");
		355
		356	IPath classY = env.addClass(root, "q", "Y",
		357	"package q;\n"+
		358	"public class Y {\n" +
		359	" void bar(p.X x) {\n" +
		360	" x.foo();\n" +
		361	" }\n" +
		362	"}"
		363	);
		364
		365	fullBuild(projectPath);
		366	expectingNoProblems();
		367
		368	long lastModified = new java.io.File(externalLib).lastModified();
		369	try {
		370	Thread.sleep(1000);
		371	} catch(InterruptedException e) {
		372	}
		373	org.eclipse.jdt.core.tests.util.Util.createJar(
		374	new String[] {
		375	"p/X.java",
		376	"package p;\n" +
		377	"public class X {\n" +
		378	"}"
		379	},
		380	externalLib,
		381	"1.4");
		382	new java.io.File(externalLib).setLastModified(lastModified + 1000); // to be sure its different
		383
		384	IJavaProject p = env.getJavaProject(projectPath);
		385	p.getJavaModel().refreshExternalArchives(new IJavaElement[] {p}, null);
		386
		387	incrementalBuild(projectPath);
		388	expectingProblemsFor(
		389	classY,
		390	"Problem : The method foo() is undefined for the type X [ resource : </Project/q/Y.java> range : <54,57> category : <50> severity : <2>]"
		391	);
		392	} finally {
		393	new File(externalLib).delete();
		394	}
		395	}
396
397	/*
398	* Ensures that changing a type in an internal ZIP archive and refreshing triggers a rebuild
399	*/
400	public void testChangeZIPArchive2() throws Exception {
401	IPath projectPath = env.addProject("Project");
402	String internalLib = env.getProject("Project").getLocation().toOSString() + File.separator + "internalLib.abc";
403	env.addExternalJars(projectPath, Util.getJavaClassLibs());
404	env.addEntry(projectPath, JavaCore.newLibraryEntry(new Path("/Project/internalLib.abc"), null, null));
405	org.eclipse.jdt.core.tests.util.Util.createJar(
406	new String[] {
407	"p/X.java",
408	"package p;\n" +
409	"public class X {\n" +
410	" public void foo() {\n" +
411	" }\n" +
412	"}"
413	},
414	internalLib,
415	"1.4");
416	env.getProject(projectPath).refreshLocal(IResource.DEPTH_INFINITE, null);
417
418	IPath root = env.getPackageFragmentRootPath(projectPath, ""); //$NON-NLS-1$
419	env.setOutputFolder(projectPath, "");
420
421	IPath classY = env.addClass(root, "q", "Y",
422	"package q;\n"+
423	"public class Y {\n" +
424	" void bar(p.X x) {\n" +
425	" x.foo();\n" +
426	" }\n" +
427	"}"
428	);
429
430	fullBuild(projectPath);
431	expectingNoProblems();
432
433	long lastModified = new java.io.File(internalLib).lastModified();
434	try {
435	Thread.sleep(1000);
436	} catch(InterruptedException e) {
437	}
438	org.eclipse.jdt.core.tests.util.Util.createJar(
439	new String[] {
440	"p/X.java",
441	"package p;\n" +
442	"public class X {\n" +
443	"}"
444	},
445	internalLib,
446	"1.4");
447	new java.io.File(internalLib).setLastModified(lastModified + 1000); // to be sure its different
448
449	env.getProject(projectPath).refreshLocal(IResource.DEPTH_INFINITE, null);
450
451	incrementalBuild(projectPath);
452	expectingProblemsFor(
453	classY,
454	"Problem : The method foo() is undefined for the type X [ resource : </Project/q/Y.java> range : <54,57> category : <50> severity : <2>]"
455	);
456	}
457
458	/*
332	* Ensures that changing an external jar and refreshing the projects triggers a rebuild	459	* Ensures that changing an external jar and refreshing the projects triggers a rebuild
333	* (regression test for bug 50207 Compile errors fixed by 'refresh' do not reset problem list or package explorer error states)	460	* (regression test for bug 50207 Compile errors fixed by 'refresh' do not reset problem list or package explorer error states)
334	*/	461	*/