Attachment #160747 for bug #304081

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




			return false;

		// then look at resolved entries
		IClasspathEntry[] resolvedClasspath = null;
		try {
			resolvedClasspath = getResolvedClasspath();
		} catch(JavaModelException e){
			return false; // Perhaps, not a Java project
					try {
						container = JavaCore.getClasspathContainer(rawEntry.getPath(), this);
					} catch (JavaModelException e) {
						break;
					}
					if (container == null)
						break;
					IClasspathEntry[] containerEntries = container.getClasspathEntries();
					if (containerEntries == null)
						break;
					// container was bound
					for (int j = 0, containerLength = containerEntries.length; j < containerLength; j++){
						IClasspathEntry resolvedEntry = containerEntries[j];
						if (resolvedEntry == null) {
							if (JavaModelManager.CP_RESOLVE_VERBOSE || JavaModelManager.CP_RESOLVE_VERBOSE_FAILURE) {
								JavaModelManager.getJavaModelManager().verbose_missbehaving_container(this, rawEntry.getPath(), containerEntries);
							}
							return false;
						}
						if (isOnClasspathEntry(elementPath, isFolderPath, isPackageFragmentRoot, resolvedEntry))
							return true;
					}
					break;
				case IClasspathEntry.CPE_VARIABLE:
					IClasspathEntry resolvedEntry = JavaCore.getResolvedClasspathEntry(rawEntry);
					if (resolvedEntry == null)
						break;
					if (isOnClasspathEntry(elementPath, isFolderPath, isPackageFragmentRoot, resolvedEntry))
						return true;
					break;
			}
		}

		for (int index = 0; index< resolvedClasspath.length; index++) {
			if (isOnClasspathEntry(elementPath, isFolderPath, isPackageFragmentRoot, resolvedClasspath[index]))
				return true;
		}
		return false;
	}





static {
	// Names of tests to run: can be "testBugXXXX" or "BugXXXX")
//	TESTS_PREFIX = "testClasspathDuplicateExtraAttribute";
//	TESTS_NAMES = new String[] {"testBug304081"};
//	TESTS_NUMBERS = new int[] { 23, 28, 38 };
//	TESTS_RANGE = new int[] { 21, 38 };
}

 */
public void testNoResourceChange06() throws CoreException {
	ILogListener listener = new ILogListener(){
		private final StringBuffer buffer = new StringBuffer();
		public void logging(IStatus status, String plugin) {
			this.buffer.append(status);
			this.buffer.append('\n');

		deleteProject("P");
	}
}
/**
 * @bug 304081:IJavaProject#isOnClasspath(IJavaElement) returns false for type from referenced JAR
 * When the JAR, which a variable classpath entry resolves to, references other JAR via
 * MANIFEST, test that {@link IJavaProject#isOnClasspath(IJavaElement)} returns true
 * for the referenced classpath entries. 
 * 
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=304081"
 * @throws Exception
 */
public void testBug304081() throws Exception {
	File libDir = null;
	try {

		IJavaProject proj = this.createJavaProject("P", new String[] {}, "bin");
		IPath libPath = proj.getResource().getLocation();
		JavaCore.setClasspathVariable("MyVar", libPath, null);
		libDir = new File(libPath.toPortableString());
		IClasspathEntry[] classpath = new IClasspathEntry[1];
		File libJar = new File(libDir, "variable.jar");
		libJar.createNewFile();
		
		addLibrary(proj, "variable.jar", null, new String[0], 
				new String[] {
				"META-INF/MANIFEST.MF",
				"Manifest-Version: 1.0\n" +
				"Class-Path: lib1.jar\n",
			},
			JavaCore.VERSION_1_4); 

		createFile("/P/lib1.jar", "");
		
		classpath[0] = JavaCore.newVariableEntry(new Path(
				"/MyVar/variable.jar"), null, null);
		
		proj.setRawClasspath(classpath, null);
		waitForAutoBuild();
		IProject project = getWorkspaceRoot().getProject("P");
		IResource resource = project.getFile("variable.jar");
		assertTrue(proj.isOnClasspath(resource));
		IJavaElement element = proj.getPackageFragmentRoot(resource);
		assertTrue(proj.isOnClasspath(element));

		resource = project.getFile("lib1.jar");
		assertTrue(proj.isOnClasspath(resource));
		element = proj.getPackageFragmentRoot(resource);
		assertTrue(proj.isOnClasspath(element));
	} finally {
		this.deleteProject("P");
		JavaCore.removeClasspathVariable("MyVar", null);
	}
}
/**
 * Additional tests for 304081
 * When the JAR, which is in the raw classpath, references other JAR via
 * MANIFEST, test that {@link IJavaProject#isOnClasspath(IJavaElement)} returns true
 * for the referenced classpath entries. 
 * 
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=304081"
 * @throws Exception
 */
public void testBug304081a() throws Exception {
	try {

		IJavaProject proj = this.createJavaProject("P", new String[] {}, "bin");
		IClasspathEntry[] classpath = new IClasspathEntry[1];

		addLibrary(proj, "library.jar", null, new String[0], 
				new String[] {
					"META-INF/MANIFEST.MF",
					"Manifest-Version: 1.0\n" +
					"Class-Path: lib1.jar\n",
				},
				JavaCore.VERSION_1_4);
		createFile("/P/lib1.jar", "");	
		classpath[0] = JavaCore.newLibraryEntry(new Path("/P/library.jar"), null, null);
		
		proj.setRawClasspath(classpath, null);
		waitForAutoBuild();
		IProject project = getWorkspaceRoot().getProject("P");
		IResource resource = project.getFile("library.jar");
		assertTrue(proj.isOnClasspath(resource));
		IJavaElement element = proj.getPackageFragmentRoot(resource);
		assertTrue(proj.isOnClasspath(element));

		resource = project.getFile("lib1.jar");
		assertTrue(proj.isOnClasspath(resource));
		element = proj.getPackageFragmentRoot(resource);
		assertTrue(proj.isOnClasspath(element));
	} finally {
		this.deleteProject("P");
	}
}
/**
 * Additional tests for 304081
 * When the JAR, which is part of a classpath container, references other JAR via
 * MANIFEST, test that {@link IJavaProject#isOnClasspath(IJavaElement)} returns true
 * for the referenced classpath entries. 
 * 
 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=304081"
 * @throws Exception
 */
public void testBug304081b() throws Exception {
	File libDir = null;
	try {

		IJavaProject proj = this.createJavaProject("P", new String[] {}, "bin");
		IClasspathEntry[] classpath = new IClasspathEntry[1];
		File libJar = new File(libDir, "container.jar");
		
		addLibrary(proj, "container.jar", null, new String[0], 
				new String[] {
					"META-INF/MANIFEST.MF",
					"Manifest-Version: 1.0\n" +
					"Class-Path: lib1.jar\n",
				},
				JavaCore.VERSION_1_4);
		createFile("/P/lib1.jar", "");
		
		ClasspathContainerInitializer initializer= JavaCore.getClasspathContainerInitializer(JavaCore.USER_LIBRARY_CONTAINER_ID);
		String libraryName = "TestUserLibrary";
		IPath containerPath = new Path(JavaCore.USER_LIBRARY_CONTAINER_ID);
		UserLibraryClasspathContainer containerSuggestion = new UserLibraryClasspathContainer(libraryName);
		initializer.requestClasspathContainerUpdate(containerPath.append(libraryName), null, containerSuggestion);

		IEclipsePreferences preferences = new InstanceScope().getNode(JavaCore.PLUGIN_ID);
		String propertyName = JavaModelManager.CP_USERLIBRARY_PREFERENCES_PREFIX+"TestUserLibrary";
		StringBuffer propertyValue = new StringBuffer("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<userlibrary systemlibrary=\"false\" version=\"1\">\r\n<archive");
		propertyValue.append(" path=\"" + libJar.getAbsolutePath());
		propertyValue.append("\"/>\r\n</userlibrary>\r\n");
		preferences.put(propertyName, propertyValue.toString());
		preferences.flush();	
		
		classpath[0] = JavaCore.newContainerEntry(containerSuggestion.getPath());
		
		proj.setRawClasspath(classpath, null);
		waitForAutoBuild();
		IProject project = getWorkspaceRoot().getProject("P");
		IResource resource = project.getFile("container.jar");
		assertTrue(proj.isOnClasspath(resource));
		IJavaElement element = proj.getPackageFragmentRoot(resource);
		assertTrue(proj.isOnClasspath(element));

		resource = project.getFile("lib1.jar");
		assertTrue(proj.isOnClasspath(resource));
		element = proj.getPackageFragmentRoot(resource);
		assertTrue(proj.isOnClasspath(element));
		
	} finally {
		this.deleteProject("P");
	}
}

}

Return to bug 304081

Lines 2159-2202 Link Here

(-)model/org/eclipse/jdt/internal/core/JavaProject.java (-36 / +9 lines)
2159	return false;	2159	return false;
2160		2160
2161	// then look at resolved entries	2161	// then look at resolved entries
2162	for (int i = 0; i < length; i++) {	2162	IClasspathEntry[] resolvedClasspath = null;
2163	IClasspathEntry rawEntry = rawClasspath[i];	2163	try {
2164	switch (rawEntry.getEntryKind()) {	2164	resolvedClasspath = getResolvedClasspath();
2165	case IClasspathEntry.CPE_CONTAINER:	2165	} catch(JavaModelException e){
2166	IClasspathContainer container;	2166	return false; // Perhaps, not a Java project
2167	try {
2168	container = JavaCore.getClasspathContainer(rawEntry.getPath(), this);
2169	} catch (JavaModelException e) {
2170	break;
2171	}
2172	if (container == null)
2173	break;
2174	IClasspathEntry[] containerEntries = container.getClasspathEntries();
2175	if (containerEntries == null)
2176	break;
2177	// container was bound
2178	for (int j = 0, containerLength = containerEntries.length; j < containerLength; j++){
2179	IClasspathEntry resolvedEntry = containerEntries[j];
2180	if (resolvedEntry == null) {
2181	if (JavaModelManager.CP_RESOLVE_VERBOSE \|\| JavaModelManager.CP_RESOLVE_VERBOSE_FAILURE) {
2182	JavaModelManager.getJavaModelManager().verbose_missbehaving_container(this, rawEntry.getPath(), containerEntries);
2183	}
2184	return false;
2185	}
2186	if (isOnClasspathEntry(elementPath, isFolderPath, isPackageFragmentRoot, resolvedEntry))
2187	return true;
2188	}
2189	break;
2190	case IClasspathEntry.CPE_VARIABLE:
2191	IClasspathEntry resolvedEntry = JavaCore.getResolvedClasspathEntry(rawEntry);
2192	if (resolvedEntry == null)
2193	break;
2194	if (isOnClasspathEntry(elementPath, isFolderPath, isPackageFragmentRoot, resolvedEntry))
2195	return true;
2196	break;
2197	}
2198	}	2167	}
2199		2168
		2169	for (int index = 0; index< resolvedClasspath.length; index++) {
		2170	if (isOnClasspathEntry(elementPath, isFolderPath, isPackageFragmentRoot, resolvedClasspath[index]))
		2171	return true;
		2172	}
2200	return false;	2173	return false;
2201	}	2174	}
2202		2175

Lines 89-95 Link Here

(-)src/org/eclipse/jdt/core/tests/model/ClasspathTests.java (-2 / +153 lines)
89	static {	89	static {
90	// Names of tests to run: can be "testBugXXXX" or "BugXXXX")	90	// Names of tests to run: can be "testBugXXXX" or "BugXXXX")
91	// TESTS_PREFIX = "testClasspathDuplicateExtraAttribute";	91	// TESTS_PREFIX = "testClasspathDuplicateExtraAttribute";
92	// TESTS_NAMES = new String[] {"testClasspathValidation42"};	92	// TESTS_NAMES = new String[] {"testBug304081"};
93	// TESTS_NUMBERS = new int[] { 23, 28, 38 };	93	// TESTS_NUMBERS = new int[] { 23, 28, 38 };
94	// TESTS_RANGE = new int[] { 21, 38 };	94	// TESTS_RANGE = new int[] { 21, 38 };
95	}	95	}
Lines 4881-4887 Link Here
4881	*/	4881	*/
4882	public void testNoResourceChange06() throws CoreException {	4882	public void testNoResourceChange06() throws CoreException {
4883	ILogListener listener = new ILogListener(){	4883	ILogListener listener = new ILogListener(){
4884	private StringBuffer buffer = new StringBuffer();	4884	private final StringBuffer buffer = new StringBuffer();
4885	public void logging(IStatus status, String plugin) {	4885	public void logging(IStatus status, String plugin) {
4886	this.buffer.append(status);	4886	this.buffer.append(status);
4887	this.buffer.append('\n');	4887	this.buffer.append('\n');
Lines 6427-6431 Link Here
6427	deleteProject("P");	6427	deleteProject("P");
6428	}	6428	}
6429	}	6429	}
		6430	/**
		6431	* @bug 304081:IJavaProject#isOnClasspath(IJavaElement) returns false for type from referenced JAR
		6432	* When the JAR, which a variable classpath entry resolves to, references other JAR via
		6433	* MANIFEST, test that {@link IJavaProject#isOnClasspath(IJavaElement)} returns true
		6434	* for the referenced classpath entries.
		6435	*
		6436	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=304081"
		6437	* @throws Exception
		6438	*/
		6439	public void testBug304081() throws Exception {
		6440	File libDir = null;
		6441	try {
		6442
		6443	IJavaProject proj = this.createJavaProject("P", new String[] {}, "bin");
		6444	IPath libPath = proj.getResource().getLocation();
		6445	JavaCore.setClasspathVariable("MyVar", libPath, null);
		6446	libDir = new File(libPath.toPortableString());
		6447	IClasspathEntry[] classpath = new IClasspathEntry[1];
		6448	File libJar = new File(libDir, "variable.jar");
		6449	libJar.createNewFile();
		6450
		6451	addLibrary(proj, "variable.jar", null, new String[0],
		6452	new String[] {
		6453	"META-INF/MANIFEST.MF",
		6454	"Manifest-Version: 1.0\n" +
		6455	"Class-Path: lib1.jar\n",
		6456	},
		6457	JavaCore.VERSION_1_4);
		6458
		6459	createFile("/P/lib1.jar", "");
		6460
		6461	classpath[0] = JavaCore.newVariableEntry(new Path(
		6462	"/MyVar/variable.jar"), null, null);
		6463
		6464	proj.setRawClasspath(classpath, null);
		6465	waitForAutoBuild();
		6466	IProject project = getWorkspaceRoot().getProject("P");
		6467	IResource resource = project.getFile("variable.jar");
		6468	assertTrue(proj.isOnClasspath(resource));
		6469	IJavaElement element = proj.getPackageFragmentRoot(resource);
		6470	assertTrue(proj.isOnClasspath(element));
		6471
		6472	resource = project.getFile("lib1.jar");
		6473	assertTrue(proj.isOnClasspath(resource));
		6474	element = proj.getPackageFragmentRoot(resource);
		6475	assertTrue(proj.isOnClasspath(element));
		6476	} finally {
		6477	this.deleteProject("P");
		6478	JavaCore.removeClasspathVariable("MyVar", null);
		6479	}
		6480	}
		6481	/**
		6482	* Additional tests for 304081
		6483	* When the JAR, which is in the raw classpath, references other JAR via
		6484	* MANIFEST, test that {@link IJavaProject#isOnClasspath(IJavaElement)} returns true
		6485	* for the referenced classpath entries.
		6486	*
		6487	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=304081"
		6488	* @throws Exception
		6489	*/
		6490	public void testBug304081a() throws Exception {
		6491	try {
		6492
		6493	IJavaProject proj = this.createJavaProject("P", new String[] {}, "bin");
6494	IClasspathEntry[] classpath = new IClasspathEntry[1];
6495
6496	addLibrary(proj, "library.jar", null, new String[0],
6497	new String[] {
6498	"META-INF/MANIFEST.MF",
6499	"Manifest-Version: 1.0\n" +
6500	"Class-Path: lib1.jar\n",
6501	},
6502	JavaCore.VERSION_1_4);
6503	createFile("/P/lib1.jar", "");
6504	classpath[0] = JavaCore.newLibraryEntry(new Path("/P/library.jar"), null, null);
6505
6506	proj.setRawClasspath(classpath, null);
6507	waitForAutoBuild();
6508	IProject project = getWorkspaceRoot().getProject("P");
6509	IResource resource = project.getFile("library.jar");
6510	assertTrue(proj.isOnClasspath(resource));
6511	IJavaElement element = proj.getPackageFragmentRoot(resource);
6512	assertTrue(proj.isOnClasspath(element));
6513
6514	resource = project.getFile("lib1.jar");
6515	assertTrue(proj.isOnClasspath(resource));
6516	element = proj.getPackageFragmentRoot(resource);
6517	assertTrue(proj.isOnClasspath(element));
6518	} finally {
6519	this.deleteProject("P");
6520	}
6521	}
6522	/**
6523	* Additional tests for 304081
6524	* When the JAR, which is part of a classpath container, references other JAR via
6525	* MANIFEST, test that {@link IJavaProject#isOnClasspath(IJavaElement)} returns true
6526	* for the referenced classpath entries.
6527	*
6528	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=304081"
6529	* @throws Exception
6530	*/
6531	public void testBug304081b() throws Exception {
6532	File libDir = null;
6533	try {
6534
6535	IJavaProject proj = this.createJavaProject("P", new String[] {}, "bin");
6536	IClasspathEntry[] classpath = new IClasspathEntry[1];
6537	File libJar = new File(libDir, "container.jar");
6538
6539	addLibrary(proj, "container.jar", null, new String[0],
6540	new String[] {
6541	"META-INF/MANIFEST.MF",
6542	"Manifest-Version: 1.0\n" +
6543	"Class-Path: lib1.jar\n",
6544	},
6545	JavaCore.VERSION_1_4);
6546	createFile("/P/lib1.jar", "");
6547
6548	ClasspathContainerInitializer initializer= JavaCore.getClasspathContainerInitializer(JavaCore.USER_LIBRARY_CONTAINER_ID);
6549	String libraryName = "TestUserLibrary";
6550	IPath containerPath = new Path(JavaCore.USER_LIBRARY_CONTAINER_ID);
6551	UserLibraryClasspathContainer containerSuggestion = new UserLibraryClasspathContainer(libraryName);
6552	initializer.requestClasspathContainerUpdate(containerPath.append(libraryName), null, containerSuggestion);
6553
6554	IEclipsePreferences preferences = new InstanceScope().getNode(JavaCore.PLUGIN_ID);
6555	String propertyName = JavaModelManager.CP_USERLIBRARY_PREFERENCES_PREFIX+"TestUserLibrary";
6556	StringBuffer propertyValue = new StringBuffer("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<userlibrary systemlibrary=\"false\" version=\"1\">\r\n<archive");
6557	propertyValue.append(" path=\"" + libJar.getAbsolutePath());
6558	propertyValue.append("\"/>\r\n</userlibrary>\r\n");
6559	preferences.put(propertyName, propertyValue.toString());
6560	preferences.flush();
6561
6562	classpath[0] = JavaCore.newContainerEntry(containerSuggestion.getPath());
6563
6564	proj.setRawClasspath(classpath, null);
6565	waitForAutoBuild();
6566	IProject project = getWorkspaceRoot().getProject("P");
6567	IResource resource = project.getFile("container.jar");
6568	assertTrue(proj.isOnClasspath(resource));
6569	IJavaElement element = proj.getPackageFragmentRoot(resource);
6570	assertTrue(proj.isOnClasspath(element));
6571
6572	resource = project.getFile("lib1.jar");
6573	assertTrue(proj.isOnClasspath(resource));
6574	element = proj.getPackageFragmentRoot(resource);
6575	assertTrue(proj.isOnClasspath(element));
6576
6577	} finally {
6578	this.deleteProject("P");
6579	}
6580	}
6430		6581
6431	}	6582	}