Attachment #59863 for bug #172345

Lines 10-15 Link Here

(-)src/org/eclipse/jdt/core/tests/builder/BuilderTests.java (-21 / +52 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.jdt.core.tests.builder;	11	package org.eclipse.jdt.core.tests.builder;
12		12
		13	import java.util.Arrays;
13	import java.util.Enumeration;	14	import java.util.Enumeration;
14	import java.util.Hashtable;	15	import java.util.Hashtable;
15	import java.util.Vector;	16	import java.util.Vector;
Lines 192-205 Link Here
192	/** Verifies that the given elements have no problems.	193	/** Verifies that the given elements have no problems.
193	*/	194	*/
194	protected void expectingNoProblemsFor(IPath[] roots) {	195	protected void expectingNoProblemsFor(IPath[] roots) {
195	if (DEBUG)	196	StringBuffer buffer = new StringBuffer();
196	printProblemsFor(roots);	197	Problem[] allProblems = allSortedProblems(roots);
197		198	if (allProblems != null) {
198	for (int i = 0; i < roots.length; i++) {	199	for (int i=0, length=allProblems.length; i<length; i++) {
199	Problem[] problems = env.getProblemsFor(roots[i]);	200	buffer.append(allProblems[i]+"\n");
200	if (problems.length != 0)	201	}
201	assertTrue("unexpected problem(s) : " + problems[0], false); //$NON-NLS-1$
202	}	202	}
		203	String actual = buffer.toString();
		204	assumeEquals("Unexpected problem(s)!!!", "", actual); //$NON-NLS-1$
203	}	205	}
204		206
205	/** Verifies that the given element has problems and	207	/** Verifies that the given element has problems and
Lines 284-304 Link Here
284		286
285	/** Verifies that the given element has problems.	287	/** Verifies that the given element has problems.
286	*/	288	*/
287	protected void expectingProblemsFor(IPath expected) {	289	protected void expectingProblemsFor(IPath root, String expected) {
288	expectingProblemsFor(new IPath[] { expected });	290	expectingProblemsFor(new IPath[] { root }, expected);
289	}	291	}
290		292
291	/** Verifies that the given elements have problems.	293	/** Verifies that the given elements have problems.
292	*/	294	*/
293	protected void expectingProblemsFor(IPath[] expected) {	295	protected void expectingProblemsFor(IPath[] roots, String expected) {
294	if (DEBUG)	296	StringBuffer buffer = new StringBuffer();
295	printProblemsFor(expected);	297	Problem[] allProblems = allSortedProblems(roots);
296		298	if (allProblems != null) {
297	for (int i = 0; i < expected.length; i++) {	299	for (int i=0, length=allProblems.length; i<length; i++) {
298	/* get the leaf problems for this type */	300	if (i>0) buffer.append('\n');
299	Problem[] problems = env.getProblemsFor(expected[i]);	301	buffer.append(allProblems[i]);
300	assertTrue("missing expected problem with " + expected[i].toString(), problems.length > 0); //$NON-NLS-1$	302	}
301	}	303	}
		304	String actual = buffer.toString();
		305	assumeEquals("Invalid problem(s)!!!", expected, actual); //$NON-NLS-1$
302	}	306	}
303		307
304	/** Verifies that the given element has a specific problem.	308	/** Verifies that the given element has a specific problem.
Lines 325-334 Link Here
325	}	329	}
326	}	330	}
327	}	331	}
328	System.out.println("--------------------------------------------------------------------------------");
329	System.out.println("Missing problem while running test "+getName()+":");
330	System.out.println(" - expected : " + problem);
331	System.out.println(" - current: " + problemsToString(rootProblems));
332	/*	332	/*
333	for (int j = 0; j < rootProblems.length; j++) {	333	for (int j = 0; j < rootProblems.length; j++) {
334	Problem pb = rootProblems[j];	334	Problem pb = rootProblems[j];
Lines 339-344 Link Here
339	}	339	}
340	}	340	}
341	*/	341	*/
		342	System.out.println("--------------------------------------------------------------------------------");
		343	System.out.println("Missing problem while running test "+getName()+":");
		344	System.out.println(" - expected : " + problem);
		345	System.out.println(" - current: " + problemsToString(rootProblems));
342	assumeTrue("missing expected problem: " + problem, false);	346	assumeTrue("missing expected problem: " + problem, false);
343	}	347	}
344	}	348	}
Lines 429-434 Link Here
429	super.tearDown();	433	super.tearDown();
430	}	434	}
431		435
		436	/**
		437	* Concatenate and sort all problems for given root paths.
		438	*
		439	* @param roots The path to get the problems
		440	* @return All sorted problems of all given path
		441	*/
		442	Problem[] allSortedProblems(IPath[] roots) {
		443	Problem[] allProblems = null;
		444	for (int i = 0, max=roots.length; i<max; i++) {
		445	Problem[] problems = env.getProblemsFor(roots[i]);
		446	int length = problems.length;
		447	if (problems.length != 0) {
		448	if (allProblems == null) {
		449	allProblems = problems;
		450	} else {
		451	int all = allProblems.length;
		452	System.arraycopy(allProblems, 0, allProblems = new Problem[all+length], 0, all);
		453	System.arraycopy(problems, 0, allProblems , all, length);
		454	}
		455	}
		456	}
		457	if (allProblems != null) {
		458	Arrays.sort(allProblems);
		459	}
		460	return allProblems;
		461	}
		462
432	public static Test suite() {	463	public static Test suite() {
433	TestSuite suite = new TestSuite();	464	TestSuite suite = new TestSuite();
434		465

Lines 57-63 Link Here

(-)src/org/eclipse/jdt/core/tests/builder/IncrementalTests.java (-5 / +19 lines)
57	"class CC {}");	57	"class CC {}");
58		58
59	incrementalBuild(projectPath);	59	incrementalBuild(projectPath);
60	expectingProblemsFor(new IPath[]{ pathToD });	60	expectingProblemsFor(
		61	pathToD,
		62	"Problem : The type CC is already defined [ resource : </Project/src/p/D.java> range : <37,39> category : <-1> severity : <2>]"
		63	);
61	expectingSpecificProblemsFor(pathToD, new Problem[] {new Problem("", "The type CC is already defined", pathToD, 37, 39, -1, IMarker.SEVERITY_ERROR)});	64	expectingSpecificProblemsFor(pathToD, new Problem[] {new Problem("", "The type CC is already defined", pathToD, 37, 39, -1, IMarker.SEVERITY_ERROR)});
62	}	65	}
63		66
Lines 183-189 Link Here
183	"public class C extends B { }"); //$NON-NLS-1$	186	"public class C extends B { }"); //$NON-NLS-1$
184		187
185	incrementalBuild(projectPath);	188	incrementalBuild(projectPath);
186	expectingProblemsFor(new IPath[]{ pathToA, pathToB, pathToC });	189	expectingProblemsFor(
		190	new IPath[]{ pathToA, pathToB, pathToC },
		191	"Problem : The public type _A must be defined in its own file [ resource : </Project/src/p/A.java> range : <25,27> category : <40> severity : <2>]\n" +
		192	"Problem : A cannot be resolved to a type [ resource : </Project/src/p/B.java> range : <35,36> category : <40> severity : <2>]\n" +
		193	"Problem : The hierarchy of the type C is inconsistent [ resource : </Project/src/p/C.java> range : <25,26> category : <40> severity : <2>]"
		194	);
187	expectingSpecificProblemFor(pathToA, new Problem("_A", "The public type _A must be defined in its own file", pathToA, 25, 27, CategorizedProblem.CAT_TYPE, IMarker.SEVERITY_ERROR)); //$NON-NLS-1$ //$NON-NLS-2$	195	expectingSpecificProblemFor(pathToA, new Problem("_A", "The public type _A must be defined in its own file", pathToA, 25, 27, CategorizedProblem.CAT_TYPE, IMarker.SEVERITY_ERROR)); //$NON-NLS-1$ //$NON-NLS-2$
188	expectingSpecificProblemFor(pathToB, new Problem("B", "A cannot be resolved to a type", pathToB, 35, 36, CategorizedProblem.CAT_TYPE, IMarker.SEVERITY_ERROR)); //$NON-NLS-1$ //$NON-NLS-2$	196	expectingSpecificProblemFor(pathToB, new Problem("B", "A cannot be resolved to a type", pathToB, 35, 36, CategorizedProblem.CAT_TYPE, IMarker.SEVERITY_ERROR)); //$NON-NLS-1$ //$NON-NLS-2$
189	expectingSpecificProblemFor(pathToC, new Problem("C", "The hierarchy of the type C is inconsistent", pathToC, 25, 26, CategorizedProblem.CAT_TYPE, IMarker.SEVERITY_ERROR)); //$NON-NLS-1$ //$NON-NLS-2$	197	expectingSpecificProblemFor(pathToC, new Problem("C", "The hierarchy of the type C is inconsistent", pathToC, 25, 26, CategorizedProblem.CAT_TYPE, IMarker.SEVERITY_ERROR)); //$NON-NLS-1$ //$NON-NLS-2$
Lines 252-258 Link Here
252	"}"); //$NON-NLS-1$	260	"}"); //$NON-NLS-1$
253		261
254	incrementalBuild(projectPath);	262	incrementalBuild(projectPath);
255	expectingProblemsFor(new IPath[]{ pathToAB });	263	expectingProblemsFor(
		264	pathToAB,
		265	"Problem : AZ cannot be resolved to a type [ resource : </Project/src/p/AB.java> range : <36,38> category : <40> severity : <2>]"
		266	);
256	expectingSpecificProblemFor(pathToAB, new Problem("AB", "AZ cannot be resolved to a type", pathToAB, 36, 38, CategorizedProblem.CAT_TYPE, IMarker.SEVERITY_ERROR)); //$NON-NLS-1$ //$NON-NLS-2$	267	expectingSpecificProblemFor(pathToAB, new Problem("AB", "AZ cannot be resolved to a type", pathToAB, 36, 38, CategorizedProblem.CAT_TYPE, IMarker.SEVERITY_ERROR)); //$NON-NLS-1$ //$NON-NLS-2$
257		268
258	env.addClass(root, "p", "AA", //$NON-NLS-1$ //$NON-NLS-2$	269	env.addClass(root, "p", "AA", //$NON-NLS-1$ //$NON-NLS-2$
Lines 319-325 Link Here
319	"}"); //$NON-NLS-1$	330	"}"); //$NON-NLS-1$
320		331
321	incrementalBuild(projectPath);	332	incrementalBuild(projectPath);
322	expectingProblemsFor(new IPath[]{ pathToBB });	333	expectingProblemsFor(
		334	pathToBB,
		335	"Problem : ZA cannot be resolved to a type [ resource : </Project/src/p/BB.java> range : <104,106> category : <40> severity : <2>]"
		336	);
323	expectingSpecificProblemFor(pathToBB, new Problem("BB.foo()", "ZA cannot be resolved to a type", pathToBB, 104, 106, CategorizedProblem.CAT_TYPE, IMarker.SEVERITY_ERROR)); //$NON-NLS-1$ //$NON-NLS-2$	337	expectingSpecificProblemFor(pathToBB, new Problem("BB.foo()", "ZA cannot be resolved to a type", pathToBB, 104, 106, CategorizedProblem.CAT_TYPE, IMarker.SEVERITY_ERROR)); //$NON-NLS-1$ //$NON-NLS-2$
324		338
325	env.addClass(root, "p", "ZZ", //$NON-NLS-1$ //$NON-NLS-2$	339	env.addClass(root, "p", "ZZ", //$NON-NLS-1$ //$NON-NLS-2$
Lines 619-625 Link Here
619	);	633	);
620		634
621	incrementalBuild();	635	incrementalBuild();
622	expectingProblemsFor(x);	636	expectingProblemsFor(x, "???");
623	expectingNoPresenceOf(bin.append("X.class")); //$NON-NLS-1$	637	expectingNoPresenceOf(bin.append("X.class")); //$NON-NLS-1$
624	}	638	}
625		639




import org.eclipse.core.resources.IMarker;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.preferences.IEclipsePreferences;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.compiler.CategorizedProblem;
import org.eclipse.jdt.core.tests.util.Util;
import org.eclipse.jdt.internal.core.JavaModelManager;

/**
 * Basic tests of the image builder.

		fullBuild(projectPath);
		expectingNoProblems();
	}

	/**
	 * @bug 75471: [prefs] no re-compile when loading settings
	 * @test Ensure that changing project preferences is well taking into account while rebuilding project
	 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=75471"
	 */
	public void _testUpdateProjectPreferences() throws JavaModelException {
		
		IPath projectPath = env.addProject("Project"); //$NON-NLS-1$
		env.addExternalJars(projectPath, Util.getJavaClassLibs());

		// remove old package fragment root so that names don't collide
		env.removePackageFragmentRoot(projectPath, ""); //$NON-NLS-1$

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

		env.addClass(root, "util", "MyException", //$NON-NLS-1$ //$NON-NLS-2$
			"package util;\n" + 
			"public class MyException extends Exception {\n" + 
			"	private static final long serialVersionUID = 1L;\n" +
			"}"
		); //$NON-NLS-1$

		IPath cuPath = env.addClass(root, "p", "Test", //$NON-NLS-1$ //$NON-NLS-2$
			"package p;\n" + 
			"import util.MyException;\n" + 
			"public class Test {\n" + 
			"}"
		);

		fullBuild(projectPath);
		expectingSpecificProblemFor(
			projectPath,
			new Problem("", "The import util.MyException is never used", cuPath, 18, 34, CategorizedProblem.CAT_UNNECESSARY_CODE, IMarker.SEVERITY_WARNING)); //$NON-NLS-1$ //$NON-NLS-2$

		IJavaProject project = env.getJavaProject(projectPath);
		project.setOption(JavaCore.COMPILER_PB_UNUSED_IMPORT, JavaCore.IGNORE);
		incrementalBuild(projectPath);
		expectingNoProblems();
	}
	public void _testUpdateWkspPreferences() throws JavaModelException {
		
		IPath projectPath = env.addProject("Project"); //$NON-NLS-1$
		env.addExternalJars(projectPath, Util.getJavaClassLibs());

		// remove old package fragment root so that names don't collide
		env.removePackageFragmentRoot(projectPath, ""); //$NON-NLS-1$

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

		env.addClass(root, "util", "MyException", //$NON-NLS-1$ //$NON-NLS-2$
			"package util;\n" + 
			"public class MyException extends Exception {\n" + 
			"	private static final long serialVersionUID = 1L;\n" +
			"}"
		); //$NON-NLS-1$

		IPath cuPath = env.addClass(root, "p", "Test", //$NON-NLS-1$ //$NON-NLS-2$
			"package p;\n" + 
			"import util.MyException;\n" + 
			"public class Test {\n" + 
			"}"
		);

		fullBuild();
		expectingSpecificProblemFor(
			projectPath,
			new Problem("", "The import util.MyException is never used", cuPath, 18, 34, CategorizedProblem.CAT_UNNECESSARY_CODE, IMarker.SEVERITY_WARNING)); //$NON-NLS-1$ //$NON-NLS-2$

		// Save preference
		JavaModelManager manager = JavaModelManager.getJavaModelManager();
		IEclipsePreferences preferences = manager.getInstancePreferences();
		String unusedImport = preferences.get(JavaCore.COMPILER_PB_UNUSED_IMPORT, null);
		try {
			// Modify preference
			preferences.put(JavaCore.COMPILER_PB_UNUSED_IMPORT, JavaCore.IGNORE);
			incrementalBuild();
			expectingNoProblems();
		}
		finally {
			if (unusedImport == null) {
				preferences.remove(JavaCore.COMPILER_PB_UNUSED_IMPORT);
			} else {
				preferences.put(JavaCore.COMPILER_PB_UNUSED_IMPORT, unusedImport);
			}
		}
	}
	
}

Lines 268-274 Link Here

(-)src/org/eclipse/jdt/core/tests/builder/DependencyTests.java (-1 / +4 lines)
268		268
269	// build -> expecting problems	269	// build -> expecting problems
270	fullBuild();	270	fullBuild();
271	expectingProblemsFor(classTest);	271	expectingProblemsFor(
		272	classTest,
		273	"Problem : The method bar() is undefined for the type Y [ resource : </Project/p/X.java> range : <57,60> category : <50> severity : <2>]"
		274	);
272		275
273	try {	276	try {
274	Thread.sleep(1000);	277	Thread.sleep(1000);

Lines 54-60 Link Here

(-)src/org/eclipse/jdt/core/tests/builder/Java50Tests.java (-3 / +12 lines)
54	);	54	);
55		55
56	incrementalBuild(projectPath);	56	incrementalBuild(projectPath);
57	expectingProblemsFor(usePath);	57	expectingProblemsFor(
		58	usePath,
		59	"Problem : The annotation @Ann is disallowed for this location [ resource : </Project/p/Use.java> range : <11,17> category : <40> severity : <2>]"
		60	);
58	}	61	}
59		62
60	public void testParameterizedType1() throws JavaModelException {	63	public void testParameterizedType1() throws JavaModelException {
Lines 92-98 Link Here
92	);	95	);
93		96
94	incrementalBuild(projectPath);	97	incrementalBuild(projectPath);
95	expectingProblemsFor(usePath);	98	expectingProblemsFor(
		99	usePath,
		100	"Problem : The method foo(List<Object>) in the type Other is not applicable for the arguments (ArrayList<String>) [ resource : </Project/p/Use.java> range : <104,107> category : <50> severity : <2>]"
		101	);
96	}	102	}
97		103
98	public void testParameterizedType2() throws JavaModelException {	104	public void testParameterizedType2() throws JavaModelException {
Lines 130-136 Link Here
130	);	136	);
131		137
132	incrementalBuild(projectPath);	138	incrementalBuild(projectPath);
133	expectingProblemsFor(usePath);	139	expectingProblemsFor(
		140	usePath,
		141	"Problem : Unhandled exception type Exception [ resource : </Project/p/Use.java> range : <92,132> category : <40> severity : <2>]"
		142	);
134	}	143	}
135		144
136	}	145	}




import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.*;
import org.eclipse.core.runtime.preferences.IEclipsePreferences;
import org.eclipse.jdt.core.*;
import org.eclipse.jdt.core.compiler.CategorizedProblem;
import org.eclipse.jdt.core.tests.util.AbstractCompilerTest;


public class BuildpathTests extends BuilderTests {

public BuildpathTests(String name) {
	super(name);
}

	public static Test suite() {
		return buildTestSuite(BuildpathTests.class);
	}
	public void testClasspathFileChange() throws JavaModelException {
		// create project with src folder, and alternate unused src2 folder
		IPath projectPath = env.addProject("Project"); //$NON-NLS-1$
		env.removePackageFragmentRoot(projectPath, ""); //$NON-NLS-1$
		IPath root = env.addPackageFragmentRoot(projectPath, "src"); //$NON-NLS-1$
		env.addExternalJars(projectPath, Util.getJavaClassLibs());
		env.setOutputFolder(projectPath, "bin"); //$NON-NLS-1$
		IPath classTest1 = env.addClass(root, "p1", "Test1", //$NON-NLS-1$ //$NON-NLS-2$
			"package p1;\n"+ //$NON-NLS-1$
			"public class Test1 extends Zork1 {}" //$NON-NLS-1$
		);
		// not yet on the classpath
		IPath src2Path = env.addFolder(projectPath, "src2"); //$NON-NLS-1$
		IPath src2p1Path = env.addFolder(src2Path, "p1"); //$NON-NLS-1$
		env.addFile(src2p1Path, "Zork1.java", //$NON-NLS-1$ //$NON-NLS-2$
			"package p1;\n"+ //$NON-NLS-1$
			"public class Zork1 {}" //$NON-NLS-1$
		);

		fullBuild();
		expectingSpecificProblemFor(classTest1, new Problem("src", "Zork1 cannot be resolved to a type", classTest1,39, 44, CategorizedProblem.CAT_TYPE, IMarker.SEVERITY_ERROR)); //$NON-NLS-1$ //$NON-NLS-2$

public static Test suite() {
	return buildTestSuite(BuildpathTests.class);
}
		StringBuffer buffer = new StringBuffer("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"); //$NON-NLS-1$
		buffer.append("<classpath>\n"); //$NON-NLS-1$
		buffer.append("    <classpathentry kind=\"src\" path=\"src\"/>\n"); //$NON-NLS-1$
		buffer.append("    <classpathentry kind=\"src\" path=\"src2\"/>\n"); // add src2 on classpath through resource change //$NON-NLS-1$
		String[] classlibs = Util.getJavaClassLibs();
		for (int i = 0; i < classlibs.length; i++) {
			buffer.append("    <classpathentry kind=\"lib\" path=\"").append(classlibs[i]).append("\"/>\n"); //$NON-NLS-1$ //$NON-NLS-2$
		}
		buffer.append("    <classpathentry kind=\"output\" path=\"bin\"/>\n"); //$NON-NLS-1$
		buffer.append("</classpath>"); //$NON-NLS-1$
		boolean wasAutoBuilding = env.isAutoBuilding();
		try {
			// turn autobuild on
			env.setAutoBuilding(true);
			// write new .classpath, will trigger autobuild
			env.addFile(projectPath, ".classpath", buffer.toString()); //$NON-NLS-1$
			// ensures the builder did see the classpath change
			env.waitForAutoBuild();
			expectingNoProblems();
		} finally {
			env.setAutoBuilding(wasAutoBuilding);
		}
	}	

private String getJdkLevelProblem(String expectedRuntime, String path, int severity) {
	Object target = JavaModel.getTarget(ResourcesPlugin.getWorkspace().getRoot(), new Path(path).makeAbsolute(), true);
	long libraryJDK = org.eclipse.jdt.internal.core.util.Util.getJdkLevel(target);
	String jclRuntime = CompilerOptions.versionFromJdkLevel(libraryJDK);
	StringBuffer jdkLevelProblem = new StringBuffer("Problem : Incompatible .class files version in required binaries. Project 'Project' is targeting a ");
	jdkLevelProblem.append(expectedRuntime);
	jdkLevelProblem.append(" runtime, but is compiled against '");
	jdkLevelProblem.append(path);
	jdkLevelProblem.append("' which requires a ");
	jdkLevelProblem.append(jclRuntime);
	jdkLevelProblem.append(" runtime [ resource : </Project> range : <-1,-1> category : <10> severity : <");
	jdkLevelProblem.append(severity);
	jdkLevelProblem.append(">]");
	return jdkLevelProblem.toString();
}

public void testClasspathFileChange() throws JavaModelException {
	// create project with src folder, and alternate unused src2 folder
	IPath projectPath = env.addProject("Project"); //$NON-NLS-1$
	env.removePackageFragmentRoot(projectPath, ""); //$NON-NLS-1$
	IPath root = env.addPackageFragmentRoot(projectPath, "src"); //$NON-NLS-1$
	env.addExternalJars(projectPath, Util.getJavaClassLibs());
	env.setOutputFolder(projectPath, "bin"); //$NON-NLS-1$
	IPath classTest1 = env.addClass(root, "p1", "Test1", //$NON-NLS-1$ //$NON-NLS-2$
		"package p1;\n"+ //$NON-NLS-1$
		"public class Test1 extends Zork1 {}" //$NON-NLS-1$
	);
	// not yet on the classpath
	IPath src2Path = env.addFolder(projectPath, "src2"); //$NON-NLS-1$
	IPath src2p1Path = env.addFolder(src2Path, "p1"); //$NON-NLS-1$
	env.addFile(src2p1Path, "Zork1.java", //$NON-NLS-1$ //$NON-NLS-2$
		"package p1;\n"+ //$NON-NLS-1$
		"public class Zork1 {}" //$NON-NLS-1$
	);

	fullBuild();
	expectingSpecificProblemFor(classTest1, new Problem("src", "Zork1 cannot be resolved to a type", classTest1,39, 44, CategorizedProblem.CAT_TYPE, IMarker.SEVERITY_ERROR)); //$NON-NLS-1$ //$NON-NLS-2$
		//----------------------------
		env.closeProject(project1Path);

	//----------------------------
	//           Step 2
	//----------------------------	
	StringBuffer buffer = new StringBuffer("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"); //$NON-NLS-1$
	buffer.append("<classpath>\n"); //$NON-NLS-1$
	buffer.append("    <classpathentry kind=\"src\" path=\"src\"/>\n"); //$NON-NLS-1$
	buffer.append("    <classpathentry kind=\"src\" path=\"src2\"/>\n"); // add src2 on classpath through resource change //$NON-NLS-1$
	String[] classlibs = Util.getJavaClassLibs();
	for (int i = 0; i < classlibs.length; i++) {
		buffer.append("    <classpathentry kind=\"lib\" path=\"").append(classlibs[i]).append("\"/>\n"); //$NON-NLS-1$ //$NON-NLS-2$
	}
	buffer.append("    <classpathentry kind=\"output\" path=\"bin\"/>\n"); //$NON-NLS-1$
	buffer.append("</classpath>"); //$NON-NLS-1$
	boolean wasAutoBuilding = env.isAutoBuilding();
	try {
		// turn autobuild on
		env.setAutoBuilding(true);
		// write new .classpath, will trigger autobuild
		env.addFile(projectPath, ".classpath", buffer.toString()); //$NON-NLS-1$
		// ensures the builder did see the classpath change
		env.waitForAutoBuild();
		expectingNoProblems();
	} finally {
		env.setAutoBuilding(wasAutoBuilding);
	}
}	

public void testClosedProject() throws JavaModelException {
	IPath project1Path = env.addProject("CP1"); //$NON-NLS-1$
	env.addExternalJars(project1Path, Util.getJavaClassLibs());
	IPath jarPath = env.addInternalJar(project1Path, "temp.jar", new byte[] {0}); //$NON-NLS-1$

	IPath project2Path = env.addProject("CP2"); //$NON-NLS-1$
	env.addExternalJars(project2Path, Util.getJavaClassLibs());
	env.addRequiredProject(project2Path, project1Path);

	IPath project3Path = env.addProject("CP3"); //$NON-NLS-1$
	env.addExternalJars(project3Path, Util.getJavaClassLibs());
	env.addExternalJar(project3Path, jarPath.toString());

	fullBuild();
	expectingNoProblems();
		expectingNoProblems();

	//----------------------------
	//           Step 2
	//----------------------------
	env.closeProject(project1Path);
		options.put(JavaCore.CORE_JAVA_BUILD_INVALID_CLASSPATH, JavaCore.IGNORE);
		JavaCore.setOptions(options);
		env.closeProject(project1Path);

	incrementalBuild();
	expectingOnlyProblemsFor(new IPath[] {project2Path, project3Path});
	expectingOnlySpecificProblemsFor(project2Path,
		new Problem[] {
			new Problem("", "The project cannot be built until build path errors are resolved", project2Path, -1, -1, CategorizedProblem.CAT_BUILDPATH, IMarker.SEVERITY_ERROR), //$NON-NLS-1$ //$NON-NLS-2$
			new Problem("Build path", "Project 'CP2' is missing required Java project: 'CP1'", project2Path, -1, -1, CategorizedProblem.CAT_BUILDPATH, IMarker.SEVERITY_ERROR) //$NON-NLS-1$ //$NON-NLS-2$
		}
	);
	expectingOnlySpecificProblemsFor(project3Path,
		new Problem[] {
			new Problem("", "The project cannot be built until build path errors are resolved", project3Path, -1, -1, CategorizedProblem.CAT_BUILDPATH, IMarker.SEVERITY_ERROR), //$NON-NLS-1$ //$NON-NLS-2$
			new Problem("Build path", "Project 'CP3' is missing required library: '/CP1/temp.jar'", project3Path, -1, -1, CategorizedProblem.CAT_BUILDPATH, IMarker.SEVERITY_ERROR) //$NON-NLS-1$ //$NON-NLS-2$
		}
	);

	env.openProject(project1Path);
	incrementalBuild();
	expectingNoProblems();

	//----------------------------
	//           Step 3
	//----------------------------
	Hashtable options = JavaCore.getOptions();
	options.put(JavaCore.CORE_JAVA_BUILD_INVALID_CLASSPATH, JavaCore.IGNORE);
	JavaCore.setOptions(options);
	env.closeProject(project1Path);

	incrementalBuild();
	expectingOnlyProblemsFor(new IPath[] {project2Path, project3Path});
	expectingOnlySpecificProblemFor(project2Path,
		new Problem("Build path", "Project 'CP2' is missing required Java project: 'CP1'", project2Path, -1, -1, CategorizedProblem.CAT_BUILDPATH, IMarker.SEVERITY_ERROR) //$NON-NLS-1$ //$NON-NLS-2$
	);
	expectingOnlySpecificProblemFor(project3Path,
		new Problem("Build path", "Project 'CP3' is missing required library: '/CP1/temp.jar'", project3Path, -1, -1, CategorizedProblem.CAT_BUILDPATH, IMarker.SEVERITY_ERROR) //$NON-NLS-1$ //$NON-NLS-2$
	);

	env.openProject(project1Path);
	incrementalBuild();
	expectingNoProblems();

	options.put(JavaCore.CORE_JAVA_BUILD_INVALID_CLASSPATH, JavaCore.ABORT);
	JavaCore.setOptions(options);
}

public void testCorruptBuilder() throws JavaModelException {
	IPath project1Path = env.addProject("P1"); //$NON-NLS-1$
	env.addExternalJars(project1Path, Util.getJavaClassLibs());

	env.addClass(project1Path, "p", "Test", //$NON-NLS-1$ //$NON-NLS-2$
		"package p;" + //$NON-NLS-1$
		"public class Test {}" //$NON-NLS-1$
	);

	fullBuild();
	expectingNoProblems();

	IPath outputFolderPackage = env.getOutputLocation(project1Path).append("p"); //$NON-NLS-1$
	env.removeBinaryClass(outputFolderPackage, "Test"); //$NON-NLS-1$
			"public class Test {}" //$NON-NLS-1$
		);

	IPath subTest = env.addClass(project1Path, "", "SubTest", //$NON-NLS-1$ //$NON-NLS-2$
		"public class SubTest extends p.Test {}" //$NON-NLS-1$
	);

	incrementalBuild();
	expectingOnlySpecificProblemFor(subTest, new Problem("", "p.Test cannot be resolved to a type", subTest, 29, 35, CategorizedProblem.CAT_TYPE, IMarker.SEVERITY_ERROR)); //$NON-NLS-1$ //$NON-NLS-2$)
		JavaCore.setOptions(options);

	env.addClass(project1Path, "p", "Test", //$NON-NLS-1$ //$NON-NLS-2$
		"package p;" + //$NON-NLS-1$
		"public class Test {}" //$NON-NLS-1$
	);

	fullBuild();
	expectingNoProblems();

	Hashtable options = JavaCore.getOptions();
	options.put(JavaCore.CORE_JAVA_BUILD_RECREATE_MODIFIED_CLASS_FILES_IN_OUTPUT_FOLDER, JavaCore.ENABLED);
	JavaCore.setOptions(options);

	env.removeBinaryClass(outputFolderPackage, "Test"); //$NON-NLS-1$
		IPath project1Path = env.addProject("P1"); //$NON-NLS-1$
		env.addExternalJars(project1Path, Util.getJavaClassLibs());
		env.removePackageFragmentRoot(project1Path, ""); //$NON-NLS-1$
		IPath src = env.addPackageFragmentRoot(project1Path, "src"); //$NON-NLS-1$
		IPath bin = env.setOutputFolder(project1Path, "bin"); //$NON-NLS-1$

		env.addClass(src, "p", "Test", //$NON-NLS-1$ //$NON-NLS-2$
			"package p;" + //$NON-NLS-1$
			"public class Test {}" //$NON-NLS-1$
		);

	incrementalBuild();
	expectingNoProblems();

	options.put(JavaCore.CORE_JAVA_BUILD_RECREATE_MODIFIED_CLASS_FILES_IN_OUTPUT_FOLDER, JavaCore.IGNORE);
	JavaCore.setOptions(options);
}

public void testCorruptBuilder2() throws JavaModelException {
	IPath project1Path = env.addProject("P1"); //$NON-NLS-1$
	env.addExternalJars(project1Path, Util.getJavaClassLibs());
	env.removePackageFragmentRoot(project1Path, ""); //$NON-NLS-1$
	IPath src = env.addPackageFragmentRoot(project1Path, "src"); //$NON-NLS-1$
	IPath bin = env.setOutputFolder(project1Path, "bin"); //$NON-NLS-1$

	env.addClass(src, "p", "Test", //$NON-NLS-1$ //$NON-NLS-2$
		"package p;" + //$NON-NLS-1$
		"public class Test {}" //$NON-NLS-1$
	);

	fullBuild();
	expectingNoProblems();

	IPath outputFolderPackage = bin.append("p"); //$NON-NLS-1$
	env.removeBinaryClass(outputFolderPackage, "Test"); //$NON-NLS-1$
			"public class Test {}" //$NON-NLS-1$
		);

	IPath subTest = env.addClass(src, "p2", "SubTest", //$NON-NLS-1$ //$NON-NLS-2$
		"package p2;" + //$NON-NLS-1$
		"public class SubTest extends p.Test {}" //$NON-NLS-1$
	);

	incrementalBuild();
	expectingOnlySpecificProblemFor(subTest, new Problem("", "p.Test cannot be resolved to a type", subTest, 40, 46, CategorizedProblem.CAT_TYPE, IMarker.SEVERITY_ERROR)); //$NON-NLS-1$ //$NON-NLS-2$)
		JavaCore.setOptions(options);

	env.addClass(src, "p", "Test", //$NON-NLS-1$ //$NON-NLS-2$
		"package p;" + //$NON-NLS-1$
		"public class Test {}" //$NON-NLS-1$
	);

	fullBuild();
	expectingNoProblems();

	Hashtable options = JavaCore.getOptions();
	options.put(JavaCore.CORE_JAVA_BUILD_RECREATE_MODIFIED_CLASS_FILES_IN_OUTPUT_FOLDER, JavaCore.ENABLED);
	JavaCore.setOptions(options);

	env.removeBinaryClass(outputFolderPackage, "Test"); //$NON-NLS-1$
	 * 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)
	 */
	public void testExternalJarChange() throws JavaModelException, IOException {
		// setup
		IPath projectPath = env.addProject("Project"); //$NON-NLS-1$
		env.addExternalJars(projectPath, Util.getJavaClassLibs());
		IPath root = env.getPackageFragmentRootPath(projectPath, ""); //$NON-NLS-1$
		IPath classTest = env.addClass(root, "p", "X", //$NON-NLS-1$ //$NON-NLS-2$
			"package p;\n"+ //$NON-NLS-1$
			"public class X {\n" + //$NON-NLS-1$
			"  void foo() {\n" + //$NON-NLS-1$
			"    new q.Y().bar();\n" + //$NON-NLS-1$
			"  }\n" + //$NON-NLS-1$
			"}" //$NON-NLS-1$
		);
		String externalJar = Util.getOutputDirectory() + File.separator + "test.jar"; //$NON-NLS-1$
		Util.createJar(
			new String[] {
				"q/Y.java", //$NON-NLS-1$
				"package q;\n" + //$NON-NLS-1$
				"public class Y {\n" + //$NON-NLS-1$
				"}" //$NON-NLS-1$
			},
			new HashMap(),
			externalJar
		);
		long lastModified = new java.io.File(externalJar).lastModified();
		env.addExternalJar(projectPath, externalJar);
		
		// build -> expecting problems
		fullBuild();
		expectingProblemsFor(classTest);
		
		try {
			Thread.sleep(1000);
		} catch(InterruptedException e) {
		}
		// fix jar
		Util.createJar(
			new String[] {
				"q/Y.java", //$NON-NLS-1$
				"package q;\n" + //$NON-NLS-1$
				"public class Y {\n" + //$NON-NLS-1$
				"  public void bar() {\n" + //$NON-NLS-1$
				"  }\n" + //$NON-NLS-1$
				"}" //$NON-NLS-1$
			},
			new HashMap(),
			externalJar
		);
		
		new java.io.File(externalJar).setLastModified(lastModified + 1000); // to be sure its different
		// refresh project and rebuild -> expecting no problems
		IJavaProject project = JavaCore.create(ResourcesPlugin.getWorkspace().getRoot().getProject("Project")); //$NON-NLS-1$
		project.getJavaModel().refreshExternalArchives(new IJavaElement[] {project}, null);
		incrementalBuild();
		expectingNoProblems();
		
	}

	incrementalBuild();
	expectingNoProblems();
		env.addExternalJars(project1Path, Util.getJavaClassLibs());

		IPath project2Path = env.addProject("P2"); //$NON-NLS-1$
		env.addExternalJars(project2Path, Util.getJavaClassLibs());
		env.addRequiredProject(project2Path, project1Path);

	options.put(JavaCore.CORE_JAVA_BUILD_RECREATE_MODIFIED_CLASS_FILES_IN_OUTPUT_FOLDER, JavaCore.IGNORE);
	JavaCore.setOptions(options);
}

/*
 * 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)
 */
public void testExternalJarChange() throws JavaModelException, IOException {
	// setup
	IPath projectPath = env.addProject("Project"); //$NON-NLS-1$
	env.addExternalJars(projectPath, Util.getJavaClassLibs());
	IPath root = env.getPackageFragmentRootPath(projectPath, ""); //$NON-NLS-1$
	IPath classTest = env.addClass(root, "p", "X", //$NON-NLS-1$ //$NON-NLS-2$
		"package p;\n"+ //$NON-NLS-1$
		"public class X {\n" + //$NON-NLS-1$
		"  void foo() {\n" + //$NON-NLS-1$
		"    new q.Y().bar();\n" + //$NON-NLS-1$
		"  }\n" + //$NON-NLS-1$
		"}" //$NON-NLS-1$
	);
	String externalJar = Util.getOutputDirectory() + File.separator + "test.jar"; //$NON-NLS-1$
	Util.createJar(
		new String[] {
			"q/Y.java", //$NON-NLS-1$
			"package q;\n" + //$NON-NLS-1$
			"public class Y {\n" + //$NON-NLS-1$
			"}" //$NON-NLS-1$
		},
		new HashMap(),
		externalJar
	);
	long lastModified = new java.io.File(externalJar).lastModified();
	env.addExternalJar(projectPath, externalJar);
	
	// build -> expecting problems
	fullBuild();
	expectingProblemsFor(
		classTest,
		"Problem : The method bar() is undefined for the type Y [ resource : </Project/p/X.java> range : <57,60> category : <50> severity : <2>]"
	);
	
	try {
		Thread.sleep(1000);
	} catch(InterruptedException e) {
	}
	// fix jar
	Util.createJar(
		new String[] {
			"q/Y.java", //$NON-NLS-1$
			"package q;\n" + //$NON-NLS-1$
			"public class Y {\n" + //$NON-NLS-1$
			"  public void bar() {\n" + //$NON-NLS-1$
			"  }\n" + //$NON-NLS-1$
			"}" //$NON-NLS-1$
		},
		new HashMap(),
		externalJar
	);
	
	new java.io.File(externalJar).setLastModified(lastModified + 1000); // to be sure its different
	// refresh project and rebuild -> expecting no problems
	IJavaProject project = JavaCore.create(ResourcesPlugin.getWorkspace().getRoot().getProject("Project")); //$NON-NLS-1$
	project.getJavaModel().refreshExternalArchives(new IJavaElement[] {project}, null);
	incrementalBuild();
	expectingNoProblems();
	
}

public void testMissingBuilder() throws JavaModelException {
	IPath project1Path = env.addProject("P1"); //$NON-NLS-1$
	env.addExternalJars(project1Path, Util.getJavaClassLibs());

	IPath project2Path = env.addProject("P2"); //$NON-NLS-1$
	env.addExternalJars(project2Path, Util.getJavaClassLibs());
	env.addRequiredProject(project2Path, project1Path);

	env.addClass(project1Path, "", "Test", //$NON-NLS-1$ //$NON-NLS-2$
		"public class Test {}" //$NON-NLS-1$
	);

	IPath sub = env.addClass(project2Path, "", "SubTest", //$NON-NLS-1$ //$NON-NLS-2$
		"public class SubTest extends Test {}" //$NON-NLS-1$
	);

	fullBuild();
	expectingNoProblems();

	env.removeRequiredProject(project2Path, project1Path);
			JavaProject p = (JavaProject) env.getJavaProject(project1Path);
			p.deconfigure();
			JavaModelManager.getJavaModelManager().setLastBuiltState(p.getProject(), null);
		} catch (CoreException e) {
			e.printStackTrace();
		}

	incrementalBuild();
	expectingOnlySpecificProblemFor(sub, new Problem("", "Test cannot be resolved to a type", sub, 29, 33, CategorizedProblem.CAT_TYPE, IMarker.SEVERITY_ERROR)); //$NON-NLS-1$ //$NON-NLS-2$)
		);

	env.addRequiredProject(project2Path, project1Path);
		expectingNoProblems();
	}

	try {
		JavaProject p = (JavaProject) env.getJavaProject(project1Path);
		p.deconfigure();
		JavaModelManager.getJavaModelManager().setLastBuiltState(p.getProject(), null);
	} catch (CoreException e) {
		e.printStackTrace();
	}
		);

	env.addClass(project2Path, "", "SubTest", //$NON-NLS-1$ //$NON-NLS-2$
		"public class SubTest extends Test {}" //$NON-NLS-1$
	);

	incrementalBuild();
	expectingNoProblems();
}
		IPath root2 = env.getPackageFragmentRootPath(projectPath2, ""); //$NON-NLS-1$
		env.addClass(root2, "p2", "Test2", //$NON-NLS-1$ //$NON-NLS-2$
			"package p2;\n"+ //$NON-NLS-1$
			"public class Test2 {\n" + //$NON-NLS-1$
			"	public static p1.Test field;\n" + //$NON-NLS-1$
			"}" //$NON-NLS-1$
		);

public void testMissingFieldType() throws JavaModelException {
	IPath projectPath = env.addProject("Project1"); //$NON-NLS-1$
	env.addExternalJars(projectPath, Util.getJavaClassLibs());
	IPath root = env.getPackageFragmentRootPath(projectPath, ""); //$NON-NLS-1$
	env.addClass(root, "p1", "Test", //$NON-NLS-1$ //$NON-NLS-2$
		"package p1;\n"+ //$NON-NLS-1$
		"public class Test {}" //$NON-NLS-1$
	);

	fullBuild();
	expectingNoProblems();
		env.addRequiredProject(projectPath3, projectPath2);
		IPath root3 = env.getPackageFragmentRootPath(projectPath3, ""); //$NON-NLS-1$
		env.addClass(root3, "p3", "Test3", //$NON-NLS-1$ //$NON-NLS-2$
			"package p3;\n"+ //$NON-NLS-1$
			"public class Test3 extends p2.Test2 {\n" + //$NON-NLS-1$
			"	static Object field;\n" + //$NON-NLS-1$
			"}" //$NON-NLS-1$
		);

	IPath projectPath2 = env.addProject("Project2"); //$NON-NLS-1$
	env.addExternalJars(projectPath2, Util.getJavaClassLibs());
	env.addRequiredProject(projectPath2, projectPath);
	IPath root2 = env.getPackageFragmentRootPath(projectPath2, ""); //$NON-NLS-1$
	env.addClass(root2, "p2", "Test2", //$NON-NLS-1$ //$NON-NLS-2$
		"package p2;\n"+ //$NON-NLS-1$
		"public class Test2 {\n" + //$NON-NLS-1$
		"	public static p1.Test field;\n" + //$NON-NLS-1$
		"}" //$NON-NLS-1$
	);

	incrementalBuild();
	expectingNoProblems();
		env.removePackageFragmentRoot(projectPath, ""); //$NON-NLS-1$
		IPath root = env.addPackageFragmentRoot(projectPath, "src"); //$NON-NLS-1$
		IPath bin = env.setOutputFolder(projectPath, "bin"); //$NON-NLS-1$
		IPath classTest1 = env.addClass(root, "p1", "Test1", //$NON-NLS-1$ //$NON-NLS-2$
			"package p1;\n"+ //$NON-NLS-1$
			"public class Test1 {}" //$NON-NLS-1$
		);

	IPath projectPath3 = env.addProject("Project3"); //$NON-NLS-1$
	env.addExternalJars(projectPath3, Util.getJavaClassLibs());
	env.addRequiredProject(projectPath3, projectPath2);
	IPath root3 = env.getPackageFragmentRootPath(projectPath3, ""); //$NON-NLS-1$
	env.addClass(root3, "p3", "Test3", //$NON-NLS-1$ //$NON-NLS-2$
		"package p3;\n"+ //$NON-NLS-1$
		"public class Test3 extends p2.Test2 {\n" + //$NON-NLS-1$
		"	static Object field;\n" + //$NON-NLS-1$
		"}" //$NON-NLS-1$
	);

	incrementalBuild();
	expectingNoProblems();
}
		env.addExternalJars(projectPath, Util.getJavaClassLibs());

public void testMissingLibrary1() throws JavaModelException {
	IPath projectPath = env.addProject("Project"); //$NON-NLS-1$
	env.removePackageFragmentRoot(projectPath, ""); //$NON-NLS-1$
	IPath root = env.addPackageFragmentRoot(projectPath, "src"); //$NON-NLS-1$
	IPath bin = env.setOutputFolder(projectPath, "bin"); //$NON-NLS-1$
	IPath classTest1 = env.addClass(root, "p1", "Test1", //$NON-NLS-1$ //$NON-NLS-2$
		"package p1;\n"+ //$NON-NLS-1$
		"public class Test1 {}" //$NON-NLS-1$
	);
		env.removePackageFragmentRoot(projectPath, ""); //$NON-NLS-1$
		IPath root = env.addPackageFragmentRoot(projectPath, "src"); //$NON-NLS-1$
		IPath bin = env.setOutputFolder(projectPath, "bin"); //$NON-NLS-1$
		IPath classTest1 = env.addClass(root, "p1", "Test1", //$NON-NLS-1$ //$NON-NLS-2$
			"package p1;\n"+ //$NON-NLS-1$
			"public class Test1 {}" //$NON-NLS-1$
		);
		IPath classTest2 = env.addClass(root, "p2", "Test2", //$NON-NLS-1$ //$NON-NLS-2$
			"package p2;\n"+ //$NON-NLS-1$
			"public class Test2 {}" //$NON-NLS-1$
		);
		IPath classTest3 = env.addClass(root, "p2", "Test3", //$NON-NLS-1$ //$NON-NLS-2$
			"package p2;\n"+ //$NON-NLS-1$
			"public class Test3 {}" //$NON-NLS-1$
		);

	fullBuild();
	expectingOnlyProblemsFor(new IPath[] {projectPath, classTest1});
	expectingOnlySpecificProblemsFor(projectPath,
		new Problem[] {
			new Problem("", "The project was not built since its build path is incomplete. Cannot find the class file for java.lang.Object. Fix the build path then try building this project", projectPath, -1, -1, CategorizedProblem.CAT_BUILDPATH, IMarker.SEVERITY_ERROR), //$NON-NLS-1$ //$NON-NLS-2$
			new Problem("p1", "The type java.lang.Object cannot be resolved. It is indirectly referenced from required .class files", classTest1, 0, 1, CategorizedProblem.CAT_BUILDPATH, IMarker.SEVERITY_ERROR) //$NON-NLS-1$ //$NON-NLS-2$
		Problem[] prob2 = env.getProblemsFor(classTest2);
		Problem[] prob3 = env.getProblemsFor(classTest3);
		assertEquals("too many problems", prob1.length + prob2.length + prob3.length, 1); //$NON-NLS-1$
		if(prob1.length == 1) {
			expectingSpecificProblemFor(classTest1, new Problem("p1", "The type java.lang.Object cannot be resolved. It is indirectly referenced from required .class files", classTest1, -1, -1, -1, IMarker.SEVERITY_ERROR)); //$NON-NLS-1$ //$NON-NLS-2$
		} else if (prob2.length == 1) {
			expectingSpecificProblemFor(classTest2, new Problem("p2", "The type java.lang.Object cannot be resolved. It is indirectly referenced from required .class files", classTest2, -1, -1, -1, IMarker.SEVERITY_ERROR)); //$NON-NLS-1$ //$NON-NLS-2$
		} else {
			expectingSpecificProblemFor(classTest3, new Problem("p2", "The type java.lang.Object cannot be resolved. It is indirectly referenced from required .class files", classTest3, 0, 1, CategorizedProblem.CAT_BUILDPATH, IMarker.SEVERITY_ERROR)); //$NON-NLS-1$ //$NON-NLS-2$
		}
	);

	//----------------------------
	//           Step 2
	//----------------------------	
	env.addExternalJars(projectPath, Util.getJavaClassLibs());

	incrementalBuild();
	expectingNoProblems();
	expectingPresenceOf(new IPath[]{
		bin.append("p1").append("Test1.class"), //$NON-NLS-1$ //$NON-NLS-2$
	});
	env.removeProject(projectPath);
}

public void testMissingLibrary2() throws JavaModelException {
	IPath projectPath = env.addProject("Project"); //$NON-NLS-1$
	env.removePackageFragmentRoot(projectPath, ""); //$NON-NLS-1$
	IPath root = env.addPackageFragmentRoot(projectPath, "src"); //$NON-NLS-1$
	IPath bin = env.setOutputFolder(projectPath, "bin"); //$NON-NLS-1$
	IPath classTest1 = env.addClass(root, "p1", "Test1", //$NON-NLS-1$ //$NON-NLS-2$
		"package p1;\n"+ //$NON-NLS-1$
		"public class Test1 {}" //$NON-NLS-1$
	);
	IPath classTest2 = env.addClass(root, "p2", "Test2", //$NON-NLS-1$ //$NON-NLS-2$
		"package p2;\n"+ //$NON-NLS-1$
		"public class Test2 {}" //$NON-NLS-1$
	);
	IPath classTest3 = env.addClass(root, "p2", "Test3", //$NON-NLS-1$ //$NON-NLS-2$
		"package p2;\n"+ //$NON-NLS-1$
		"public class Test3 {}" //$NON-NLS-1$
	);

	fullBuild();
	expectingSpecificProblemFor(
		projectPath,
		new Problem("", "The project was not built since its build path is incomplete. Cannot find the class file for java.lang.Object. Fix the build path then try building this project", projectPath, -1, -1, CategorizedProblem.CAT_BUILDPATH, IMarker.SEVERITY_ERROR)); //$NON-NLS-1$ //$NON-NLS-2$
	
	Problem[] prob1 = env.getProblemsFor(classTest1);
	Problem[] prob2 = env.getProblemsFor(classTest2);
	Problem[] prob3 = env.getProblemsFor(classTest3);
	assertEquals("too many problems", prob1.length + prob2.length + prob3.length, 1); //$NON-NLS-1$
	if(prob1.length == 1) {
		expectingSpecificProblemFor(classTest1, new Problem("p1", "The type java.lang.Object cannot be resolved. It is indirectly referenced from required .class files", classTest1, -1, -1, -1, IMarker.SEVERITY_ERROR)); //$NON-NLS-1$ //$NON-NLS-2$
	} else if (prob2.length == 1) {
		expectingSpecificProblemFor(classTest2, new Problem("p2", "The type java.lang.Object cannot be resolved. It is indirectly referenced from required .class files", classTest2, -1, -1, -1, IMarker.SEVERITY_ERROR)); //$NON-NLS-1$ //$NON-NLS-2$
	} else {
		expectingSpecificProblemFor(classTest3, new Problem("p2", "The type java.lang.Object cannot be resolved. It is indirectly referenced from required .class files", classTest3, 0, 1, CategorizedProblem.CAT_BUILDPATH, IMarker.SEVERITY_ERROR)); //$NON-NLS-1$ //$NON-NLS-2$
	}

	//----------------------------
	//           Step 2
	//----------------------------	
	env.addExternalJars(projectPath, Util.getJavaClassLibs());

	incrementalBuild();
	expectingNoProblems();
	expectingPresenceOf(new IPath[]{
		bin.append("p1").append("Test1.class"), //$NON-NLS-1$ //$NON-NLS-2$
		bin.append("p2").append("Test2.class"), //$NON-NLS-1$ //$NON-NLS-2$
		bin.append("p2").append("Test3.class") //$NON-NLS-1$ //$NON-NLS-2$
	});
	env.removeProject(projectPath);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=172345
public void testMissingLibrary3() throws JavaModelException {
	this.abortOnFailure = false; // this test is failing on some releng boxes => do not abort on failures

	expectingSpecificProblemFor(
		projectPath,
		new Problem("Build path", "Project 'Project' is missing required library: 'lib/dummy.jar'", projectPath, -1, -1, CategorizedProblem.CAT_BUILDPATH, IMarker.SEVERITY_ERROR));
	env.removeProject(projectPath);
}
	
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=172345

		projectPath,
		new Problem("Build path", "Project 'Project' is missing required library: 'lib/dummy.jar'", projectPath, -1, -1, CategorizedProblem.CAT_BUILDPATH, IMarker.SEVERITY_ERROR));
	project.setOption(JavaCore.CORE_INCOMPLETE_CLASSPATH, CompilerOptions.WARNING);
	incrementalBuild();
	expectingSpecificProblemFor(
		projectPath,
		new Problem("Build path", "Project 'Project' is missing required library: 'lib/dummy.jar'", projectPath, -1, -1, CategorizedProblem.CAT_BUILDPATH,
				IMarker.SEVERITY_WARNING));
	env.removeProject(projectPath);
}
// https://bugs.eclipse.org/bugs/show_bug.cgi?id=172345
public void testIncompatibleJdkLEvelOnProject() throws JavaModelException {
	this.abortOnFailure = false; // NOT sure this test will pass on releng boxes => do not abort on failures
	
	// Create project
	IPath projectPath = env.addProject("Project");
	IJavaProject project = env.getJavaProject(projectPath);
	String[] classlibs = Util.getJavaClassLibs();
	env.addExternalJars(projectPath, classlibs);
	
	// Build it expecting no problem
	fullBuild();
	expectingNoProblems();

	// Build incompatible jdk level problem string
	String jclPath = project.getPackageFragmentRoot(classlibs[0]).getPath().makeRelative().toString();
	String projectRuntime = project.getOption(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM, true);

	// Change project incompatible jdk level preferences to warning, perform incremental build and expect 1 problem
	project.setOption(JavaCore.CORE_INCOMPATIBLE_JDK_LEVEL, CompilerOptions.WARNING);
	incrementalBuild();
	expectingProblemsFor(
		projectPath,
		getJdkLevelProblem(projectRuntime, jclPath, IMarker.SEVERITY_WARNING)
	);

	// Change project incompatible jdk level preferences to error, perform incremental build and expect 2 problems
	project.setOption(JavaCore.CORE_INCOMPATIBLE_JDK_LEVEL, CompilerOptions.ERROR);
	incrementalBuild();
	expectingProblemsFor(
		projectPath,
		"Problem : The project cannot be built until build path errors are resolved [ resource : </Project> range : <-1,-1> category : <10> severity : <2>]\n" + 
		getJdkLevelProblem(projectRuntime, jclPath, IMarker.SEVERITY_ERROR)
	);
	
	// Remove project to avoid side effect on other tests
	env.removeProject(projectPath);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=172345
public void testIncompatibleJdkLEvelOnWksp() throws JavaModelException {

	// Save preference
	JavaModelManager manager = JavaModelManager.getJavaModelManager();
	IEclipsePreferences preferences = manager.getInstancePreferences();
	String incompatibleJdkLevel = preferences.get(JavaCore.CORE_INCOMPATIBLE_JDK_LEVEL, null);
	try {
		this.abortOnFailure = false; // NOT sure this test will pass on all releng boxes => do not abort on failures
		
		// Create project
		IPath projectPath = env.addProject("Project");
		IJavaProject project = env.getJavaProject(projectPath);
		String[] classlibs = Util.getJavaClassLibs();
		env.addExternalJars(projectPath, classlibs);
		
		// Build it expecting no problem
		fullBuild();
		expectingNoProblems();

		// Build incompatible jdk level problem string
		String jclPath = project.getPackageFragmentRoot(classlibs[0]).getPath().makeRelative().toString();
		String wkspRuntime = JavaCore.getOption(JavaCore.COMPILER_CODEGEN_TARGET_PLATFORM);
		
		// Change workspace  incompatible jdk level preferences to warning, perform incremental build and expect 1 problem
		preferences.put(JavaCore.CORE_INCOMPATIBLE_JDK_LEVEL, JavaCore.WARNING);
		incrementalBuild();
		expectingProblemsFor(
			projectPath,
			getJdkLevelProblem(wkspRuntime, jclPath, IMarker.SEVERITY_WARNING)
		);
		
		// Change workspace incompatible jdk level preferences to error, perform incremental build and expect 2 problems
		preferences.put(JavaCore.CORE_INCOMPATIBLE_JDK_LEVEL, JavaCore.ERROR);
		incrementalBuild();
		expectingProblemsFor(
			projectPath,
			"Problem : The project cannot be built until build path errors are resolved [ resource : </Project> range : <-1,-1> category : <10> severity : <2>]\n" + 
			getJdkLevelProblem(wkspRuntime, jclPath, IMarker.SEVERITY_ERROR)
		);
		
		// Remove project to avoid side effect on other tests
		env.removeProject(projectPath);
	} finally {
		// Put back workspace preferences same as before running the test
		if (incompatibleJdkLevel == null) {
			preferences.remove(JavaCore.CORE_INCOMPATIBLE_JDK_LEVEL);
		} else {
			preferences.put(JavaCore.CORE_INCOMPATIBLE_JDK_LEVEL, incompatibleJdkLevel);
		}
	}
}

public void testMissingProject() throws JavaModelException {
	IPath project1Path = env.addProject("MP1"); //$NON-NLS-1$
	env.addExternalJars(project1Path, Util.getJavaClassLibs());

	IPath project2Path = env.addProject("MP2"); //$NON-NLS-1$
	env.addExternalJars(project2Path, Util.getJavaClassLibs());
	env.addRequiredProject(project2Path, project1Path);

	fullBuild();
	expectingNoProblems();

	//----------------------------
	//           Step 2
	//----------------------------
	env.removeProject(project1Path);
		options.put(JavaCore.CORE_JAVA_BUILD_INVALID_CLASSPATH, JavaCore.IGNORE);
		JavaCore.setOptions(options);
		env.removeProject(project1Path);

	incrementalBuild();
	expectingOnlyProblemsFor(project2Path);
	expectingOnlySpecificProblemsFor(project2Path,
		new Problem[] {
			new Problem("", "The project cannot be built until build path errors are resolved", project2Path, -1, -1, CategorizedProblem.CAT_BUILDPATH, IMarker.SEVERITY_ERROR), //$NON-NLS-1$ //$NON-NLS-2$
			new Problem("Build path", "Project 'MP2' is missing required Java project: 'MP1'", project2Path, -1, -1, CategorizedProblem.CAT_BUILDPATH, IMarker.SEVERITY_ERROR) //$NON-NLS-1$ //$NON-NLS-2$
		}
	);

	project1Path = env.addProject("MP1"); //$NON-NLS-1$
	env.addExternalJars(project1Path, Util.getJavaClassLibs());

	incrementalBuild();
	expectingNoProblems();

	//----------------------------
	//           Step 3
	//----------------------------
	Hashtable options = JavaCore.getOptions();
	options.put(JavaCore.CORE_JAVA_BUILD_INVALID_CLASSPATH, JavaCore.IGNORE);
	JavaCore.setOptions(options);
	env.removeProject(project1Path);

		IPath project2Path = env.addProject("MP2"); //$NON-NLS-1$
		env.addExternalJars(project2Path, Util.getJavaClassLibs());
		env.addRequiredProject(project2Path, project1Path, true/*optional*/);

	incrementalBuild();
	expectingOnlyProblemsFor(project2Path);
	expectingOnlySpecificProblemFor(project2Path,
		new Problem("Build path", "Project 'MP2' is missing required Java project: 'MP1'", project2Path, -1, -1, CategorizedProblem.CAT_BUILDPATH, IMarker.SEVERITY_ERROR) //$NON-NLS-1$ //$NON-NLS-2$
	);

	project1Path = env.addProject("MP1"); //$NON-NLS-1$
	env.addExternalJars(project1Path, Util.getJavaClassLibs());
		//----------------------------
		env.removeProject(project1Path);

	incrementalBuild();
	expectingNoProblems();

	options.put(JavaCore.CORE_JAVA_BUILD_INVALID_CLASSPATH, JavaCore.ABORT);
	JavaCore.setOptions(options);
}

public void testMissingOptionalProject() throws JavaModelException {
	IPath project1Path = env.addProject("MP1"); //$NON-NLS-1$
	env.addExternalJars(project1Path, Util.getJavaClassLibs());

	IPath project2Path = env.addProject("MP2"); //$NON-NLS-1$
	env.addExternalJars(project2Path, Util.getJavaClassLibs());
	env.addRequiredProject(project2Path, project1Path, true/*optional*/);

	fullBuild();
	expectingNoProblems();
		//----------------------------
		Hashtable options = JavaCore.getOptions();
		options.put(JavaCore.CORE_JAVA_BUILD_INVALID_CLASSPATH, JavaCore.IGNORE);
		JavaCore.setOptions(options);
		env.removeProject(project1Path);

	//----------------------------
	//           Step 2
	//----------------------------
	env.removeProject(project1Path);

	incrementalBuild();
	expectingNoProblems();

	project1Path = env.addProject("MP1"); //$NON-NLS-1$
	env.addExternalJars(project1Path, Util.getJavaClassLibs());

	incrementalBuild();
	expectingNoProblems();

	//----------------------------
	//           Step 3
	//----------------------------
	Hashtable options = JavaCore.getOptions();
	options.put(JavaCore.CORE_JAVA_BUILD_INVALID_CLASSPATH, JavaCore.IGNORE);
	JavaCore.setOptions(options);
	env.removeProject(project1Path);

	incrementalBuild();
	expectingNoProblems();

	project1Path = env.addProject("MP1"); //$NON-NLS-1$
	env.addExternalJars(project1Path, Util.getJavaClassLibs());

	incrementalBuild();
	expectingNoProblems();

	options.put(JavaCore.CORE_JAVA_BUILD_INVALID_CLASSPATH, JavaCore.ABORT);
	JavaCore.setOptions(options);
}

// https://bugs.eclipse.org/bugs/show_bug.cgi?id=160132
public void test0100() throws JavaModelException {

Lines 28-34 Link Here

(-)src/org/eclipse/jdt/core/tests/compiler/regression/JavadocTest.java (-1 lines)
28	static final String LINE_SEPARATOR = System.getProperty("line.separator");	28	static final String LINE_SEPARATOR = System.getProperty("line.separator");
29	public static ArrayList ALL_CLASSES = null;	29	public static ArrayList ALL_CLASSES = null;
30	static final String DOC_COMMENT_SUPPORT = System.getProperty("doc.support");	30	static final String DOC_COMMENT_SUPPORT = System.getProperty("doc.support");
31	static boolean debug = false;
32		31
33	// Javadoc execution	32	// Javadoc execution
34	protected static final String JAVADOC_NAME =	33	protected static final String JAVADOC_NAME =




import java.util.*;

import org.eclipse.jdt.core.Flags;
import org.eclipse.jdt.core.tests.util.Util;
import org.eclipse.jdt.internal.compiler.batch.Main;
import org.eclipse.test.performance.Performance;
import org.eclipse.test.performance.PerformanceTestCase;

import junit.framework.AssertionFailedError;

 * Otherwise, the thrown exception {@link AssertionFailedError} is catched
 * and its message is only displayed in the console hence producing no JUnit failure.
 */
protected void assumeEquals(String msg, String expected, String actual) {
	try {
		assertStringEquals(msg, expected, actual, false);
	} catch (ComparisonFailure cf) {
		System.out.println("Failure while running test "+Performance.getDefault().getDefaultScenarioId(this)+"!!!");
		System.out.println("Actual output is:");
		System.out.println(Util.displayString(cf.getActual(), 2));
		System.out.println();
		if (abortOnFailure) {
			throw cf;
		}
	} catch (AssertionFailedError afe) {
		if (abortOnFailure) {
			throw afe;
		}
		printAssertionFailure(afe);
	}
}

protected void assumeTrue(String msg, boolean cond) {
	try {
		assertTrue(msg, cond);
	} catch (ComparisonFailure cf) {
		if (abortOnFailure) {
			System.out.println("Failure while running test "+Performance.getDefault().getDefaultScenarioId(this)+"!!!");
			System.out.println("Actual output is:");
			System.out.println(Util.displayString(cf.getActual(), 2));
			System.out.println();
			throw cf;
		}
		printAssertionFailure(cf);
	} catch (AssertionFailedError afe) {
		if (abortOnFailure) {
			throw afe;
		}
		printAssertionFailure(afe);
	}
}

private void printAssertionFailure(AssertionFailedError afe) {
	System.out.println("\n!---!!---!!---!!---!!---!!---!!---!!---!!---!!---!!---!!---!!---!!---!!---!!---!");
	System.out.println("Catched assertion failure while running test "+getName()+":");
	System.out.println("	"+afe.getMessage());
	System.out.println("--------------------------------------------------------------------------------\n");
}




import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.StringTokenizer;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

		return null;
	}

		/**
    	 * Returns the project custom preference pool.
    	 * Project preferences may include custom encoding.
    	 * @return IEclipsePreferences
    	 */
    	public IEclipsePreferences getEclipsePreferences(){
    		if (!JavaProject.hasJavaNature(this.project)) return null;
    		// Get cached preferences if exist
    		JavaModelManager.PerProjectInfo perProjectInfo = JavaModelManager.getJavaModelManager().getPerProjectInfo(this.project, true);
    		if (perProjectInfo.preferences != null) return perProjectInfo.preferences;
    		// Init project preferences
    		IScopeContext context = new ProjectScope(getProject());
    		final IEclipsePreferences eclipsePreferences = context.getNode(JavaCore.PLUGIN_ID);
    		updatePreferences(eclipsePreferences);
    		perProjectInfo.preferences = eclipsePreferences;
    
    		// Listen to node removal from parent in order to reset cache (see bug 68993)
    		IEclipsePreferences.INodeChangeListener nodeListener = new IEclipsePreferences.INodeChangeListener() {
    			public void added(IEclipsePreferences.NodeChangeEvent event) {
    				// do nothing
    			}
    			public void removed(IEclipsePreferences.NodeChangeEvent event) {
    				if (event.getChild() == eclipsePreferences) {
    					JavaModelManager.getJavaModelManager().resetProjectPreferences(JavaProject.this);
    				}
    			}
    		};
    		((IEclipsePreferences) eclipsePreferences.parent()).addNodeChangeListener(nodeListener);
    
    		// Listen to preference changes
    		IEclipsePreferences.IPreferenceChangeListener preferenceListener = new IEclipsePreferences.IPreferenceChangeListener() {
    			public void preferenceChange(IEclipsePreferences.PreferenceChangeEvent event) {
    				JavaModelManager manager = JavaModelManager.getJavaModelManager();
    				int length = JavaCore.PLUGIN_ID.length() + 1;
    				String key = event.getKey();
    				StringTokenizer tokenizer = new StringTokenizer(key.substring(length));
    				String token = tokenizer.nextToken();
    				if (key.equals(JavaCore.CORE_JAVA_BUILD_CLEAN_OUTPUT_FOLDER) ||
    					token.equals("builder") || //$NON-NLS-1$
    					key.equals(JavaCore.CORE_INCOMPLETE_CLASSPATH) ||
    					key.equals(JavaCore.CORE_CIRCULAR_CLASSPATH) ||
    					key.equals(JavaCore.CORE_INCOMPATIBLE_JDK_LEVEL) ||
    					token.equals("classpath")) //$NON-NLS-1$
    				{
    					manager.deltaState.addClasspathValidation(JavaProject.this);
    				}
    				manager.resetProjectOptions(JavaProject.this);
    			}
    		};
    		eclipsePreferences.addPreferenceChangeListener(preferenceListener);
    		return eclipsePreferences;
    	}
		
	public String getElementName() {
		return this.project.getName();


	/**
	 * load preferences from a shareable format (VCM-wise)
	 * @deprecated WARNING, visibility of this method will be decreased soon
	 * 	to private and won't be usable in the future.
	 * @see <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=59258">bug 59258</a>
	 * TODO (frederic) set visibility from public to private
	 */
	 private Preferences loadPreferences() {
	 	
	 	Preferences preferences = new Preferences();
	 	IPath projectMetaLocation = getPluginWorkingLocation();




	/**
	 * Update the classpath variable cache
	 */
	public class EclipsePreferencesListener implements IEclipsePreferences.IPreferenceChangeListener {
		/**
         * @see org.eclipse.core.runtime.preferences.IEclipsePreferences.IPreferenceChangeListener#preferenceChange(org.eclipse.core.runtime.preferences.IEclipsePreferences.PreferenceChangeEvent)
         */
        public void preferenceChange(IEclipsePreferences.PreferenceChangeEvent event) {
        	String propertyName = event.getKey();
        	if (propertyName.startsWith(CP_VARIABLE_PREFERENCES_PREFIX)) {
        		String varName = propertyName.substring(CP_VARIABLE_PREFERENCES_PREFIX.length());
        		JavaModelManager manager = getJavaModelManager();
        		if (manager.variablesWithInitializer.contains(varName)) {
        			// revert preference value as we will not apply it to JavaCore classpath variable
        			String oldValue = (String) event.getOldValue();
        			if (oldValue == null) {
        				// unexpected old value => remove variable from set
        				manager.variablesWithInitializer.remove(varName);
        			} else {
        				manager.getInstancePreferences().put(varName, oldValue);
        			}
        		} else {
        			String newValue = (String)event.getNewValue();
        			IPath newPath;
        			if (newValue != null && !(newValue = newValue.trim()).equals(CP_ENTRY_IGNORE)) {
        				newPath = new Path(newValue);
        			} else {
        				newPath = null;
        			}
        			try {
        				SetVariablesOperation operation = new SetVariablesOperation(new String[] {varName}, new IPath[] {newPath}, false/*don't update preferences*/);
        				operation.runOperation(null/*no progress available*/);
        			} catch (JavaModelException e) {
        				Util.log(e, "Could not set classpath variable " + varName + " to " + newPath); //$NON-NLS-1$ //$NON-NLS-2$
        			}
        		}
        	}
        	else if (propertyName.startsWith(CP_CONTAINER_PREFERENCES_PREFIX)) {
        		recreatePersistedContainer(propertyName, (String)event.getNewValue(), false);
        	} else {
        		int length = JavaCore.PLUGIN_ID.length() + 1;
        		String key = event.getKey();
        		StringTokenizer tokenizer = new StringTokenizer(key.substring(length));
        		String token = tokenizer.nextToken();
        		if (key.equals(JavaCore.CORE_JAVA_BUILD_CLEAN_OUTPUT_FOLDER) ||
        			token.equals("builder") || //$NON-NLS-1$
        			key.equals(JavaCore.CORE_INCOMPLETE_CLASSPATH) ||
        			key.equals(JavaCore.CORE_CIRCULAR_CLASSPATH) ||
        			key.equals(JavaCore.CORE_INCOMPATIBLE_JDK_LEVEL) ||
        			token.equals("classpath")) //$NON-NLS-1$
        		{
        			JavaModelManager manager = JavaModelManager.getJavaModelManager();
        			IJavaModel model = manager.getJavaModel();
        			IJavaProject[] projects;
        			try {
        				projects = model.getJavaProjects();
        				for (int i = 0, pl = projects.length; i < pl; i++) {
        					JavaProject javaProject = (JavaProject) projects[i];
	    					manager.deltaState.addClasspathValidation(javaProject);
	    					try {
	    						// need to touch the project to force validation by DeltaProcessor
	                            javaProject.getProject().touch(null);
                            } catch (CoreException e) {
	                            // skip
                            }
        				}
        			} catch (JavaModelException e) {
        				// skip
        			}
        		}
        	}
        }
	}

	/**




						break;
				}
				break;
			case IResource.FOLDER :
				/* check settings change */
				IFolder folder = (IFolder) resource;
				processChildren = folder.getName().equals(JavaProject.DEFAULT_PREFERENCES_DIRNAME);
				break;
			case IResource.FILE :
				/* check classpath or prefs files change */
				IFile file = (IFile) resource;
				String fileName = file.getName();
				if (fileName.equals(JavaProject.CLASSPATH_FILENAME)) {
					fileName.equals(JavaProject.JAVA_CORE_PREFS_FILE)) {
					JavaProject javaProject = (JavaProject)JavaCore.create(file.getProject());
					this.state.addClasspathValidation(javaProject);
					affectedProjects.add(file.getProject().getFullPath());

Return to bug 172345

Lines 18-23 Link Here

(-)model/org/eclipse/jdt/internal/core/JavaProject.java (-43 / +55 lines)
18	import java.util.Hashtable;	18	import java.util.Hashtable;
19	import java.util.Iterator;	19	import java.util.Iterator;
20	import java.util.Map;	20	import java.util.Map;
		21	import java.util.StringTokenizer;
		22
21	import javax.xml.parsers.DocumentBuilder;	23	import javax.xml.parsers.DocumentBuilder;
22	import javax.xml.parsers.DocumentBuilderFactory;	24	import javax.xml.parsers.DocumentBuilderFactory;
23	import javax.xml.parsers.ParserConfigurationException;	25	import javax.xml.parsers.ParserConfigurationException;
Lines 1386-1429 Link Here
1386	return null;	1388	return null;
1387	}	1389	}
1388		1390
1389	/**	1391	/**
1390	* Returns the project custom preference pool.	1392	* Returns the project custom preference pool.
1391	* Project preferences may include custom encoding.	1393	* Project preferences may include custom encoding.
1392	* @return IEclipsePreferences	1394	* @return IEclipsePreferences
1393	*/	1395	*/
1394	public IEclipsePreferences getEclipsePreferences(){	1396	public IEclipsePreferences getEclipsePreferences(){
1395	if (!JavaProject.hasJavaNature(this.project)) return null;	1397	if (!JavaProject.hasJavaNature(this.project)) return null;
1396	// Get cached preferences if exist	1398	// Get cached preferences if exist
1397	JavaModelManager.PerProjectInfo perProjectInfo = JavaModelManager.getJavaModelManager().getPerProjectInfo(this.project, true);	1399	JavaModelManager.PerProjectInfo perProjectInfo = JavaModelManager.getJavaModelManager().getPerProjectInfo(this.project, true);
1398	if (perProjectInfo.preferences != null) return perProjectInfo.preferences;	1400	if (perProjectInfo.preferences != null) return perProjectInfo.preferences;
1399	// Init project preferences	1401	// Init project preferences
1400	IScopeContext context = new ProjectScope(getProject());	1402	IScopeContext context = new ProjectScope(getProject());
1401	final IEclipsePreferences eclipsePreferences = context.getNode(JavaCore.PLUGIN_ID);	1403	final IEclipsePreferences eclipsePreferences = context.getNode(JavaCore.PLUGIN_ID);
1402	updatePreferences(eclipsePreferences);	1404	updatePreferences(eclipsePreferences);
1403	perProjectInfo.preferences = eclipsePreferences;	1405	perProjectInfo.preferences = eclipsePreferences;
1404		1406
1405	// Listen to node removal from parent in order to reset cache (see bug 68993)	1407	// Listen to node removal from parent in order to reset cache (see bug 68993)
1406	IEclipsePreferences.INodeChangeListener nodeListener = new IEclipsePreferences.INodeChangeListener() {	1408	IEclipsePreferences.INodeChangeListener nodeListener = new IEclipsePreferences.INodeChangeListener() {
1407	public void added(IEclipsePreferences.NodeChangeEvent event) {	1409	public void added(IEclipsePreferences.NodeChangeEvent event) {
1408	// do nothing	1410	// do nothing
1409	}	1411	}
1410	public void removed(IEclipsePreferences.NodeChangeEvent event) {	1412	public void removed(IEclipsePreferences.NodeChangeEvent event) {
1411	if (event.getChild() == eclipsePreferences) {	1413	if (event.getChild() == eclipsePreferences) {
1412	JavaModelManager.getJavaModelManager().resetProjectPreferences(JavaProject.this);	1414	JavaModelManager.getJavaModelManager().resetProjectPreferences(JavaProject.this);
1413	}	1415	}
1414	}	1416	}
1415	};	1417	};
1416	((IEclipsePreferences) eclipsePreferences.parent()).addNodeChangeListener(nodeListener);	1418	((IEclipsePreferences) eclipsePreferences.parent()).addNodeChangeListener(nodeListener);
1417		1419
1418	// Listen to preference changes	1420	// Listen to preference changes
1419	IEclipsePreferences.IPreferenceChangeListener preferenceListener = new IEclipsePreferences.IPreferenceChangeListener() {	1421	IEclipsePreferences.IPreferenceChangeListener preferenceListener = new IEclipsePreferences.IPreferenceChangeListener() {
1420	public void preferenceChange(IEclipsePreferences.PreferenceChangeEvent event) {	1422	public void preferenceChange(IEclipsePreferences.PreferenceChangeEvent event) {
1421	JavaModelManager.getJavaModelManager().resetProjectOptions(JavaProject.this);	1423	JavaModelManager manager = JavaModelManager.getJavaModelManager();
1422	}	1424	int length = JavaCore.PLUGIN_ID.length() + 1;
1423	};	1425	String key = event.getKey();
1424	eclipsePreferences.addPreferenceChangeListener(preferenceListener);	1426	StringTokenizer tokenizer = new StringTokenizer(key.substring(length));
1425	return eclipsePreferences;	1427	String token = tokenizer.nextToken();
1426	}	1428	if (key.equals(JavaCore.CORE_JAVA_BUILD_CLEAN_OUTPUT_FOLDER) \|\|
		1429	token.equals("builder") \|\| //$NON-NLS-1$
		1430	key.equals(JavaCore.CORE_INCOMPLETE_CLASSPATH) \|\|
		1431	key.equals(JavaCore.CORE_CIRCULAR_CLASSPATH) \|\|
		1432	key.equals(JavaCore.CORE_INCOMPATIBLE_JDK_LEVEL) \|\|
		1433	token.equals("classpath")) //$NON-NLS-1$
		1434	{
		1435	manager.deltaState.addClasspathValidation(JavaProject.this);
		1436	}
		1437	manager.resetProjectOptions(JavaProject.this);
		1438	}
		1439	};
		1440	eclipsePreferences.addPreferenceChangeListener(preferenceListener);
		1441	return eclipsePreferences;
		1442	}
1427		1443
1428	public String getElementName() {	1444	public String getElementName() {
1429	return this.project.getName();	1445	return this.project.getName();
Lines 2159-2170 Link Here
2159		2175
2160	/**	2176	/**
2161	* load preferences from a shareable format (VCM-wise)	2177	* load preferences from a shareable format (VCM-wise)
2162	* @deprecated WARNING, visibility of this method will be decreased soon
2163	* to private and won't be usable in the future.
2164	* @see <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=59258">bug 59258</a>
2165	* TODO (frederic) set visibility from public to private
2166	*/	2178	*/
2167	public Preferences loadPreferences() {	2179	private Preferences loadPreferences() {
2168		2180
2169	Preferences preferences = new Preferences();	2181	Preferences preferences = new Preferences();
2170	IPath projectMetaLocation = getPluginWorkingLocation();	2182	IPath projectMetaLocation = getPluginWorkingLocation();

Lines 1126-1169 Link Here

(-)model/org/eclipse/jdt/internal/core/JavaModelManager.java (-37 / +68 lines)
1126	/**	1126	/**
1127	* Update the classpath variable cache	1127	* Update the classpath variable cache
1128	*/	1128	*/
1129	public static class EclipsePreferencesListener implements IEclipsePreferences.IPreferenceChangeListener {	1129	public class EclipsePreferencesListener implements IEclipsePreferences.IPreferenceChangeListener {
1130	/**	1130	/**
1131	* @see org.eclipse.core.runtime.preferences.IEclipsePreferences.IPreferenceChangeListener#preferenceChange(org.eclipse.core.runtime.preferences.IEclipsePreferences.PreferenceChangeEvent)	1131	* @see org.eclipse.core.runtime.preferences.IEclipsePreferences.IPreferenceChangeListener#preferenceChange(org.eclipse.core.runtime.preferences.IEclipsePreferences.PreferenceChangeEvent)
1132	*/	1132	*/
1133	public void preferenceChange(IEclipsePreferences.PreferenceChangeEvent event) {	1133	public void preferenceChange(IEclipsePreferences.PreferenceChangeEvent event) {
1134	String propertyName = event.getKey();	1134	String propertyName = event.getKey();
1135	if (propertyName.startsWith(CP_VARIABLE_PREFERENCES_PREFIX)) {	1135	if (propertyName.startsWith(CP_VARIABLE_PREFERENCES_PREFIX)) {
1136	String varName = propertyName.substring(CP_VARIABLE_PREFERENCES_PREFIX.length());	1136	String varName = propertyName.substring(CP_VARIABLE_PREFERENCES_PREFIX.length());
1137	JavaModelManager manager = getJavaModelManager();	1137	JavaModelManager manager = getJavaModelManager();
1138	if (manager.variablesWithInitializer.contains(varName)) {	1138	if (manager.variablesWithInitializer.contains(varName)) {
1139	// revert preference value as we will not apply it to JavaCore classpath variable	1139	// revert preference value as we will not apply it to JavaCore classpath variable
1140	String oldValue = (String) event.getOldValue();	1140	String oldValue = (String) event.getOldValue();
1141	if (oldValue == null) {	1141	if (oldValue == null) {
1142	// unexpected old value => remove variable from set	1142	// unexpected old value => remove variable from set
1143	manager.variablesWithInitializer.remove(varName);	1143	manager.variablesWithInitializer.remove(varName);
1144	} else {	1144	} else {
1145	manager.getInstancePreferences().put(varName, oldValue);	1145	manager.getInstancePreferences().put(varName, oldValue);
1146	}	1146	}
1147	} else {	1147	} else {
1148	String newValue = (String)event.getNewValue();	1148	String newValue = (String)event.getNewValue();
1149	IPath newPath;	1149	IPath newPath;
1150	if (newValue != null && !(newValue = newValue.trim()).equals(CP_ENTRY_IGNORE)) {	1150	if (newValue != null && !(newValue = newValue.trim()).equals(CP_ENTRY_IGNORE)) {
1151	newPath = new Path(newValue);	1151	newPath = new Path(newValue);
1152	} else {	1152	} else {
1153	newPath = null;	1153	newPath = null;
1154	}	1154	}
1155	try {	1155	try {
1156	SetVariablesOperation operation = new SetVariablesOperation(new String[] {varName}, new IPath[] {newPath}, false/don't update preferences/);	1156	SetVariablesOperation operation = new SetVariablesOperation(new String[] {varName}, new IPath[] {newPath}, false/don't update preferences/);
1157	operation.runOperation(null/no progress available/);	1157	operation.runOperation(null/no progress available/);
1158	} catch (JavaModelException e) {	1158	} catch (JavaModelException e) {
1159	Util.log(e, "Could not set classpath variable " + varName + " to " + newPath); //$NON-NLS-1$ //$NON-NLS-2$	1159	Util.log(e, "Could not set classpath variable " + varName + " to " + newPath); //$NON-NLS-1$ //$NON-NLS-2$
1160	}	1160	}
1161	}	1161	}
1162	}	1162	}
1163	if (propertyName.startsWith(CP_CONTAINER_PREFERENCES_PREFIX)) {	1163	else if (propertyName.startsWith(CP_CONTAINER_PREFERENCES_PREFIX)) {
1164	recreatePersistedContainer(propertyName, (String)event.getNewValue(), false);	1164	recreatePersistedContainer(propertyName, (String)event.getNewValue(), false);
1165	}	1165	} else {
1166	}	1166	int length = JavaCore.PLUGIN_ID.length() + 1;
		1167	String key = event.getKey();
		1168	StringTokenizer tokenizer = new StringTokenizer(key.substring(length));
		1169	String token = tokenizer.nextToken();
		1170	if (key.equals(JavaCore.CORE_JAVA_BUILD_CLEAN_OUTPUT_FOLDER) \|\|
		1171	token.equals("builder") \|\| //$NON-NLS-1$
		1172	key.equals(JavaCore.CORE_INCOMPLETE_CLASSPATH) \|\|
		1173	key.equals(JavaCore.CORE_CIRCULAR_CLASSPATH) \|\|
		1174	key.equals(JavaCore.CORE_INCOMPATIBLE_JDK_LEVEL) \|\|
		1175	token.equals("classpath")) //$NON-NLS-1$
		1176	{
		1177	JavaModelManager manager = JavaModelManager.getJavaModelManager();
		1178	IJavaModel model = manager.getJavaModel();
		1179	IJavaProject[] projects;
		1180	try {
		1181	projects = model.getJavaProjects();
		1182	for (int i = 0, pl = projects.length; i < pl; i++) {
		1183	JavaProject javaProject = (JavaProject) projects[i];
		1184	manager.deltaState.addClasspathValidation(javaProject);
		1185	try {
		1186	// need to touch the project to force validation by DeltaProcessor
		1187	javaProject.getProject().touch(null);
		1188	} catch (CoreException e) {
		1189	// skip
		1190	}
		1191	}
		1192	} catch (JavaModelException e) {
		1193	// skip
		1194	}
		1195	}
		1196	}
		1197	}
1167	}	1198	}
1168		1199
1169	/**	1200	/**

Lines 2189-2205 Link Here

(-)model/org/eclipse/jdt/internal/core/DeltaProcessor.java (-7 / +1 lines)
2189	break;	2189	break;
2190	}	2190	}
2191	break;	2191	break;
2192	case IResource.FOLDER :
2193	/* check settings change */
2194	IFolder folder = (IFolder) resource;
2195	processChildren = folder.getName().equals(JavaProject.DEFAULT_PREFERENCES_DIRNAME);
2196	break;
2197	case IResource.FILE :	2192	case IResource.FILE :
2198	/* check classpath or prefs files change */	2193	/* check classpath or prefs files change */
2199	IFile file = (IFile) resource;	2194	IFile file = (IFile) resource;
2200	String fileName = file.getName();	2195	String fileName = file.getName();
2201	if (fileName.equals(JavaProject.CLASSPATH_FILENAME) \|\|	2196	if (fileName.equals(JavaProject.CLASSPATH_FILENAME)) {
2202	fileName.equals(JavaProject.JAVA_CORE_PREFS_FILE)) {
2203	JavaProject javaProject = (JavaProject)JavaCore.create(file.getProject());	2197	JavaProject javaProject = (JavaProject)JavaCore.create(file.getProject());
2204	this.state.addClasspathValidation(javaProject);	2198	this.state.addClasspathValidation(javaProject);
2205	affectedProjects.add(file.getProject().getFullPath());	2199	affectedProjects.add(file.getProject().getFullPath());

Lines 19-28 Link Here

(-)src/org/eclipse/jdt/core/tests/builder/BasicBuildTests.java (+93 lines)
19	import org.eclipse.core.resources.IMarker;	19	import org.eclipse.core.resources.IMarker;
20	import org.eclipse.core.runtime.CoreException;	20	import org.eclipse.core.runtime.CoreException;
21	import org.eclipse.core.runtime.IPath;	21	import org.eclipse.core.runtime.IPath;
		22	import org.eclipse.core.runtime.preferences.IEclipsePreferences;
22	import org.eclipse.jdt.core.IJavaProject;	23	import org.eclipse.jdt.core.IJavaProject;
23	import org.eclipse.jdt.core.JavaCore;	24	import org.eclipse.jdt.core.JavaCore;
24	import org.eclipse.jdt.core.JavaModelException;	25	import org.eclipse.jdt.core.JavaModelException;
		26	import org.eclipse.jdt.core.compiler.CategorizedProblem;
25	import org.eclipse.jdt.core.tests.util.Util;	27	import org.eclipse.jdt.core.tests.util.Util;
		28	import org.eclipse.jdt.internal.core.JavaModelManager;
26		29
27	/**	30	/**
28	* Basic tests of the image builder.	31	* Basic tests of the image builder.
Lines 417-420 Link Here
417	fullBuild(projectPath);	420	fullBuild(projectPath);
418	expectingNoProblems();	421	expectingNoProblems();
419	}	422	}
		423
		424	/**
		425	* @bug 75471: [prefs] no re-compile when loading settings
		426	* @test Ensure that changing project preferences is well taking into account while rebuilding project
		427	* @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=75471"
		428	*/
		429	public void _testUpdateProjectPreferences() throws JavaModelException {
		430
		431	IPath projectPath = env.addProject("Project"); //$NON-NLS-1$
		432	env.addExternalJars(projectPath, Util.getJavaClassLibs());
		433
		434	// remove old package fragment root so that names don't collide
		435	env.removePackageFragmentRoot(projectPath, ""); //$NON-NLS-1$
		436
		437	IPath root = env.addPackageFragmentRoot(projectPath, "src"); //$NON-NLS-1$
		438	env.setOutputFolder(projectPath, "bin"); //$NON-NLS-1$
		439
		440	env.addClass(root, "util", "MyException", //$NON-NLS-1$ //$NON-NLS-2$
		441	"package util;\n" +
		442	"public class MyException extends Exception {\n" +
		443	" private static final long serialVersionUID = 1L;\n" +
		444	"}"
		445	); //$NON-NLS-1$
		446
		447	IPath cuPath = env.addClass(root, "p", "Test", //$NON-NLS-1$ //$NON-NLS-2$
		448	"package p;\n" +
		449	"import util.MyException;\n" +
		450	"public class Test {\n" +
		451	"}"
		452	);
		453
		454	fullBuild(projectPath);
		455	expectingSpecificProblemFor(
		456	projectPath,
		457	new Problem("", "The import util.MyException is never used", cuPath, 18, 34, CategorizedProblem.CAT_UNNECESSARY_CODE, IMarker.SEVERITY_WARNING)); //$NON-NLS-1$ //$NON-NLS-2$
		458
		459	IJavaProject project = env.getJavaProject(projectPath);
		460	project.setOption(JavaCore.COMPILER_PB_UNUSED_IMPORT, JavaCore.IGNORE);
		461	incrementalBuild(projectPath);
		462	expectingNoProblems();
		463	}
		464	public void _testUpdateWkspPreferences() throws JavaModelException {
		465
		466	IPath projectPath = env.addProject("Project"); //$NON-NLS-1$
		467	env.addExternalJars(projectPath, Util.getJavaClassLibs());
		468
		469	// remove old package fragment root so that names don't collide
		470	env.removePackageFragmentRoot(projectPath, ""); //$NON-NLS-1$
		471
		472	IPath root = env.addPackageFragmentRoot(projectPath, "src"); //$NON-NLS-1$
		473	env.setOutputFolder(projectPath, "bin"); //$NON-NLS-1$
		474
		475	env.addClass(root, "util", "MyException", //$NON-NLS-1$ //$NON-NLS-2$
		476	"package util;\n" +
		477	"public class MyException extends Exception {\n" +
		478	" private static final long serialVersionUID = 1L;\n" +
		479	"}"
		480	); //$NON-NLS-1$
		481
		482	IPath cuPath = env.addClass(root, "p", "Test", //$NON-NLS-1$ //$NON-NLS-2$
		483	"package p;\n" +
		484	"import util.MyException;\n" +
		485	"public class Test {\n" +
		486	"}"
487	);
488
489	fullBuild();
490	expectingSpecificProblemFor(
491	projectPath,
492	new Problem("", "The import util.MyException is never used", cuPath, 18, 34, CategorizedProblem.CAT_UNNECESSARY_CODE, IMarker.SEVERITY_WARNING)); //$NON-NLS-1$ //$NON-NLS-2$
493
494	// Save preference
495	JavaModelManager manager = JavaModelManager.getJavaModelManager();
496	IEclipsePreferences preferences = manager.getInstancePreferences();
497	String unusedImport = preferences.get(JavaCore.COMPILER_PB_UNUSED_IMPORT, null);
498	try {
499	// Modify preference
500	preferences.put(JavaCore.COMPILER_PB_UNUSED_IMPORT, JavaCore.IGNORE);
501	incrementalBuild();
502	expectingNoProblems();
503	}
504	finally {
505	if (unusedImport == null) {
506	preferences.remove(JavaCore.COMPILER_PB_UNUSED_IMPORT);
507	} else {
508	preferences.put(JavaCore.COMPILER_PB_UNUSED_IMPORT, unusedImport);
509	}
510	}
511	}
512
420	}	513	}

Lines 17-23 Link Here

(-)src/org/eclipse/jdt/core/tests/junit/extension/TestCase.java (-5 / +28 lines)
17	import java.util.*;	17	import java.util.*;
18		18
19	import org.eclipse.jdt.core.Flags;	19	import org.eclipse.jdt.core.Flags;
		20	import org.eclipse.jdt.core.tests.util.Util;
20	import org.eclipse.jdt.internal.compiler.batch.Main;	21	import org.eclipse.jdt.internal.compiler.batch.Main;
		22	import org.eclipse.test.performance.Performance;
21	import org.eclipse.test.performance.PerformanceTestCase;	23	import org.eclipse.test.performance.PerformanceTestCase;
22		24
23	import junit.framework.AssertionFailedError;	25	import junit.framework.AssertionFailedError;
Lines 239-249 Link Here
239	* Otherwise, the thrown exception {@link AssertionFailedError} is catched	241	* Otherwise, the thrown exception {@link AssertionFailedError} is catched
240	* and its message is only displayed in the console hence producing no JUnit failure.	242	* and its message is only displayed in the console hence producing no JUnit failure.
241	*/	243	*/
242	protected void assumeEquals(String msg, Object expected, Object actual) {	244	protected void assumeEquals(String msg, String expected, String actual) {
243	try {	245	try {
244	assertEquals(msg, expected, actual);	246	assertStringEquals(msg, expected, actual, false);
		247	} catch (ComparisonFailure cf) {
		248	System.out.println("Failure while running test "+Performance.getDefault().getDefaultScenarioId(this)+"!!!");
		249	System.out.println("Actual output is:");
		250	System.out.println(Util.displayString(cf.getActual(), 2));
		251	System.out.println();
		252	if (abortOnFailure) {
		253	throw cf;
		254	}
245	} catch (AssertionFailedError afe) {	255	} catch (AssertionFailedError afe) {
246	if (abortOnFailure) throw afe;	256	if (abortOnFailure) {
		257	throw afe;
		258	}
247	printAssertionFailure(afe);	259	printAssertionFailure(afe);
248	}	260	}
249	}	261	}
Lines 257-271 Link Here
257	protected void assumeTrue(String msg, boolean cond) {	269	protected void assumeTrue(String msg, boolean cond) {
258	try {	270	try {
259	assertTrue(msg, cond);	271	assertTrue(msg, cond);
		272	} catch (ComparisonFailure cf) {
		273	if (abortOnFailure) {
		274	System.out.println("Failure while running test "+Performance.getDefault().getDefaultScenarioId(this)+"!!!");
		275	System.out.println("Actual output is:");
		276	System.out.println(Util.displayString(cf.getActual(), 2));
		277	System.out.println();
		278	throw cf;
		279	}
		280	printAssertionFailure(cf);
260	} catch (AssertionFailedError afe) {	281	} catch (AssertionFailedError afe) {
261	if (abortOnFailure) throw afe;	282	if (abortOnFailure) {
		283	throw afe;
		284	}
262	printAssertionFailure(afe);	285	printAssertionFailure(afe);
263	}	286	}
264	}	287	}
265		288
266	private void printAssertionFailure(AssertionFailedError afe) {	289	private void printAssertionFailure(AssertionFailedError afe) {
267	System.out.println("\n!---!!---!!---!!---!!---!!---!!---!!---!!---!!---!!---!!---!!---!!---!!---!!---!");	290	System.out.println("\n!---!!---!!---!!---!!---!!---!!---!!---!!---!!---!!---!!---!!---!!---!!---!!---!");
268	System.out.println("Catched assertion while running test "+getName()+":");	291	System.out.println("Catched assertion failure while running test "+getName()+":");
269	System.out.println(" "+afe.getMessage());	292	System.out.println(" "+afe.getMessage());
270	System.out.println("--------------------------------------------------------------------------------\n");	293	System.out.println("--------------------------------------------------------------------------------\n");
271	}	294	}