| /******************************************************************************* |
| * Copyright (c) 2000, 2005 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.jdt.core.tests.model; |
| |
| |
| import java.io.IOException; |
| |
| import junit.framework.Test; |
| |
| import org.eclipse.core.resources.IWorkspaceRunnable; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.OperationCanceledException; |
| import org.eclipse.jdt.core.*; |
| import org.eclipse.jdt.core.compiler.CompilationParticipant; |
| import org.eclipse.jdt.core.compiler.IProblem; |
| import org.eclipse.jdt.core.compiler.ReconcileContext; |
| import org.eclipse.jdt.core.dom.AST; |
| import org.eclipse.jdt.core.tests.util.Util; |
| import org.eclipse.jdt.internal.core.CompilationUnit; |
| import org.eclipse.jdt.internal.core.JavaModelManager; |
| import org.eclipse.jdt.internal.core.search.indexing.IndexManager; |
| |
| public class ReconcilerTests extends ModifyingResourceTests { |
| |
| protected ICompilationUnit workingCopy; |
| protected ProblemRequestor problemRequestor; |
| |
| /* A problem requestor that auto-cancels on first problem */ |
| class CancelingProblemRequestor extends ProblemRequestor { |
| IProgressMonitor progressMonitor = new IProgressMonitor() { |
| boolean isCanceled = false; |
| public void beginTask(String name, int totalWork) {} |
| public void done() {} |
| public void internalWorked(double work) {} |
| public boolean isCanceled() { |
| return this.isCanceled; |
| } |
| public void setCanceled(boolean value) { |
| this.isCanceled = value; |
| } |
| public void setTaskName(String name) {} |
| public void subTask(String name) {} |
| public void worked(int work) {} |
| }; |
| |
| boolean isCanceling = false; |
| public void acceptProblem(IProblem problem) { |
| if (isCanceling) this.progressMonitor.setCanceled(true); // auto-cancel on first problem |
| super.acceptProblem(problem); |
| } |
| } |
| |
| class ReconcileParticipant extends CompilationParticipant { |
| int astLevel; |
| boolean resolveBinding; |
| IJavaElementDelta delta; |
| org.eclipse.jdt.core.dom.CompilationUnit ast; |
| ReconcileParticipant() { |
| this(ICompilationUnit.NO_AST, false); |
| } |
| ReconcileParticipant(int astLevel, boolean resolveBinding) { |
| TestCompilationParticipant.PARTICIPANT = this; |
| this.astLevel = astLevel; |
| this.resolveBinding = resolveBinding; |
| } |
| public boolean isActive(IJavaProject project) { |
| return true; |
| } |
| public void reconcile(ReconcileContext context) { |
| this.delta = context.getDelta(); |
| try { |
| this.ast = context.getAST(this.astLevel, this.resolveBinding); |
| } catch (JavaModelException e) { |
| assertNull("Unexpected exception", e); |
| } |
| } |
| } |
| /** |
| */ |
| public ReconcilerTests(String name) { |
| super(name); |
| } |
| // Use this static initializer to specify subset for tests |
| // All specified tests which do not belong to the class are skipped... |
| static { |
| // TESTS_PREFIX = "testBug36032"; |
| // TESTS_NAMES = new String[] { "testTypeWithDollarName" }; |
| // TESTS_NUMBERS = new int[] { 114338 }; |
| // TESTS_RANGE = new int[] { 16, -1 }; |
| } |
| public static Test suite() { |
| return buildTestSuite(ReconcilerTests.class); |
| } |
| protected void assertProblems(String message, String expected) { |
| assertProblems(message, expected, this.problemRequestor); |
| } |
| // Expect no error as soon as indexing is finished |
| protected void assertNoProblem(char[] source) throws InterruptedException, JavaModelException { |
| IndexManager indexManager = JavaModelManager.getJavaModelManager().getIndexManager(); |
| if (this.problemRequestor.problemCount > 0) { |
| // If errors then wait for indexes to finish |
| while (indexManager.awaitingJobsCount() > 0) { |
| Thread.sleep(100); |
| } |
| // Reconcile again to see if error goes away |
| this.problemRequestor.initialize(source); |
| this.workingCopy.reconcile(AST.JLS3, true, null, null); |
| if (this.problemRequestor.problemCount > 0) { |
| assertEquals("Working copy should NOT have any problem!", "", this.problemRequestor.problems.toString()); |
| } |
| } |
| } |
| protected void addClasspathEntries(IClasspathEntry[] entries, boolean enableForbiddenReferences) throws JavaModelException { |
| IJavaProject project = getJavaProject("Reconciler"); |
| IClasspathEntry[] oldClasspath = project.getRawClasspath(); |
| int oldLength = oldClasspath.length; |
| int length = entries.length; |
| IClasspathEntry[] newClasspath = new IClasspathEntry[oldLength+length]; |
| System.arraycopy(oldClasspath, 0, newClasspath, 0, oldLength); |
| System.arraycopy(entries, 0, newClasspath, oldLength, length); |
| project.setRawClasspath(newClasspath, null); |
| |
| if (enableForbiddenReferences) { |
| project.setOption(JavaCore.COMPILER_PB_FORBIDDEN_REFERENCE, JavaCore.ERROR); |
| } |
| } |
| protected void removeClasspathEntries(IClasspathEntry[] entries) throws JavaModelException { |
| IJavaProject project = getJavaProject("Reconciler"); |
| IClasspathEntry[] oldClasspath = project.getRawClasspath(); |
| int oldLength = oldClasspath.length; |
| int length = entries.length; |
| IClasspathEntry[] newClasspath = new IClasspathEntry[oldLength-length]; |
| System.arraycopy(oldClasspath, 0, newClasspath, 0, oldLength-length); |
| project.setRawClasspath(newClasspath, null); |
| } |
| /** |
| * Setup for the next test. |
| */ |
| public void setUp() throws Exception { |
| super.setUp(); |
| this.problemRequestor = new ProblemRequestor(); |
| this.workingCopy = getCompilationUnit("Reconciler/src/p1/X.java").getWorkingCopy(new WorkingCopyOwner() {}, this.problemRequestor, null); |
| this.problemRequestor.initialize(this.workingCopy.getSource().toCharArray()); |
| startDeltas(); |
| } |
| public void setUpSuite() throws Exception { |
| super.setUpSuite(); |
| |
| // Create project with 1.4 compliance |
| IJavaProject project14 = createJavaProject("Reconciler", new String[] {"src"}, new String[] {"JCL_LIB"}, "bin"); |
| createFolder("/Reconciler/src/p1"); |
| createFolder("/Reconciler/src/p2"); |
| createFile( |
| "/Reconciler/src/p1/X.java", |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " public void foo() {\n" + |
| " }\n" + |
| "}" |
| ); |
| project14.setOption(JavaCore.COMPILER_PB_UNUSED_LOCAL, JavaCore.IGNORE); |
| project14.setOption(JavaCore.COMPILER_PB_INVALID_JAVADOC, JavaCore.WARNING); |
| |
| // Create project with 1.5 compliance |
| IJavaProject project15 = createJavaProject("Reconciler15", new String[] {"src"}, new String[] {"JCL15_LIB"}, "bin", "1.5"); |
| addLibrary( |
| project15, |
| "lib15.jar", |
| "lib15src.zip", |
| new String[] { |
| "java/util/List.java", |
| "package java.util;\n" + |
| "public class List<T> {\n" + |
| "}", |
| "java/util/Stack.java", |
| "package java.util;\n" + |
| "public class Stack<T> {\n" + |
| "}", |
| "java/util/Map.java", |
| "package java.util;\n" + |
| "public interface Map<K,V> {\n" + |
| "}", |
| "java/lang/annotation/Annotation.java", |
| "package java.lang.annotation;\n" + |
| "public interface Annotation {\n" + |
| "}", |
| "java/lang/Deprecated.java", |
| "package java.lang;\n" + |
| "public @interface Deprecated {\n" + |
| "}", |
| "java/lang/SuppressWarnings.java", |
| "package java.lang;\n" + |
| "public @interface SuppressWarnings {\n" + |
| " String[] value();\n" + |
| "}" |
| }, |
| JavaCore.VERSION_1_5 |
| ); |
| project15.setOption(JavaCore.COMPILER_PB_UNUSED_LOCAL, JavaCore.IGNORE); |
| } |
| private void setUp15WorkingCopy() throws JavaModelException { |
| setUp15WorkingCopy("Reconciler15/src/p1/X.java", new WorkingCopyOwner() {}); |
| } |
| private void setUp15WorkingCopy(String path, WorkingCopyOwner owner) throws JavaModelException { |
| String contents = this.workingCopy.getSource(); |
| setUpWorkingCopy(path, contents, owner); |
| } |
| private void setUpWorkingCopy(String path, String contents) throws JavaModelException { |
| setUpWorkingCopy(path, contents, new WorkingCopyOwner() {}); |
| } |
| private void setUpWorkingCopy(String path, String contents, WorkingCopyOwner owner) throws JavaModelException { |
| this.workingCopy.discardWorkingCopy(); |
| this.workingCopy = getCompilationUnit(path).getWorkingCopy(owner, this.problemRequestor, null); |
| setWorkingCopyContents(contents); |
| this.workingCopy.makeConsistent(null); |
| } |
| void setWorkingCopyContents(String contents) throws JavaModelException { |
| this.workingCopy.getBuffer().setContents(contents); |
| this.problemRequestor.initialize(contents.toCharArray()); |
| } |
| /** |
| * Cleanup after the previous test. |
| */ |
| public void tearDown() throws Exception { |
| TestCompilationParticipant.PARTICIPANT = null; |
| if (this.workingCopy != null) { |
| this.workingCopy.discardWorkingCopy(); |
| } |
| stopDeltas(); |
| super.tearDown(); |
| } |
| public void tearDownSuite() throws Exception { |
| deleteProject("Reconciler"); |
| deleteProject("Reconciler15"); |
| super.tearDownSuite(); |
| } |
| /* |
| * Ensures that no problem is created for a reference to a type that is included in a prereq project. |
| */ |
| public void testAccessRestriction() throws CoreException { |
| try { |
| createJavaProject("P1", new String[] {"src"}, new String[] {"JCL_LIB"}, null, null, new String[0], null, null, new boolean[0], "bin", null, new String[][] {{"**/X.java"}}, null, "1.4"); |
| createFolder("/P1/src/p"); |
| createFile("/P1/src/p/X.java", "package p; public class X {}"); |
| |
| createJavaProject("P2", new String[] {"src"}, new String[] {"JCL_LIB"}, new String[] {"/P1"}, "bin"); |
| setUpWorkingCopy("/P2/src/Y.java", "public class Y extends p.X {}"); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "----------\n" |
| ); |
| } finally { |
| deleteProject("P1"); |
| deleteProject("P2"); |
| } |
| } |
| /* |
| * Ensures that no problem is created for a reference to a binary type that is included in a prereq project. |
| * (regression test for bug 82542 Internal error during AST creation) |
| */ |
| public void testAccessRestriction2() throws CoreException, IOException { |
| try { |
| IJavaProject project = createJavaProject("P1"); |
| addLibrary( |
| project, |
| "lib.jar", |
| "libsrc.zip", |
| new String[] { |
| "p/X.java", |
| "package p;\n" + |
| "public class X {\n" + |
| "}", |
| }, |
| new String[] { |
| "**/*" |
| }, |
| null, |
| "1.4" |
| ); |
| createJavaProject("P2", new String[] {"src"}, new String[] {"JCL_LIB"}, new String[] {"/P1"}, "bin"); |
| setUpWorkingCopy("/P2/src/Y.java", "public class Y extends p.X {}"); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "----------\n" |
| ); |
| } finally { |
| deleteProject("P1"); |
| deleteProject("P2"); |
| } |
| } |
| /* |
| * Ensures that no problem is created for a reference to a type that is included and not exported in a prereq project |
| * but with combineAccessRestriction flag set to false. |
| */ |
| public void testAccessRestriction3() throws CoreException { |
| try { |
| createJavaProject("P1"); |
| createFolder("/P1/p"); |
| createFile("/P1/p/X.java", "package p; public class X {}"); |
| |
| createJavaProject("P2", new String[] {}, new String[] {}, null, null, new String[] {"/P1"}, null, null, new boolean[] {true}, "", null, null, null, "1.4"); |
| |
| createJavaProject("P3", new String[] {"src"}, new String[] {"JCL_LIB"}, null, null, new String[] {"/P2"}, null, new String[][] {new String[] {"**/X"}}, false/*don't combine access restrictions*/, new boolean[] {true}, "bin", null, null, null, "1.4"); |
| setUpWorkingCopy("/P3/src/Y.java", "public class Y extends p.X {}"); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "----------\n" |
| ); |
| } finally { |
| deleteProjects(new String[] {"P1", "P2", "P3" }); |
| } |
| } |
| /* |
| * Ensures that a problem is created for a reference to a type that is included and not exported in a prereq project |
| * but with combineAccessRestriction flag set to true. |
| */ |
| public void testAccessRestriction4() throws CoreException { |
| try { |
| createJavaProject("P1"); |
| createFolder("/P1/p"); |
| createFile("/P1/p/X.java", "package p; public class X {}"); |
| |
| createJavaProject("P2", new String[] {}, new String[] {}, null, null, new String[] {"/P1"}, null, null, new boolean[] {true}, "", null, null, null, "1.4"); |
| |
| createJavaProject("P3", new String[] {"src"}, new String[] {"JCL_LIB"}, null, null, new String[] {"/P2"}, null, new String[][] {new String[] {"**/X"}}, true/*combine access restrictions*/, new boolean[] {true}, "bin", null, null, null, "1.4"); |
| setUpWorkingCopy("/P3/src/Y.java", "public class Y extends p.X {}"); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "1. ERROR in /P3/src/Y.java (at line 1)\n" + |
| " public class Y extends p.X {}\n" + |
| " ^^^\n" + |
| "Access restriction: The type X is not accessible due to restriction on required project P1\n" + |
| "----------\n" |
| ); |
| } finally { |
| deleteProjects(new String[] {"P1", "P2", "P3" }); |
| } |
| } |
| /* |
| * Ensures that a problem is created for a reference to a type that is no longer accessible in a prereq project. |
| * (regression test for bug 91498 Reconcile still sees old access rules) |
| */ |
| public void testAccessRestriction5() throws CoreException { |
| try { |
| createJavaProject("P1"); |
| createFolder("/P1/p"); |
| createFile("/P1/p/X.java", "package p; public class X {}"); |
| IJavaProject p2 = createJavaProject("P2", new String[] {"src"}, new String[] {"JCL_LIB"}, "bin"); |
| IClasspathEntry[] classpath = p2.getRawClasspath(); |
| int length = classpath.length; |
| System.arraycopy(classpath, 0, classpath = new IClasspathEntry[length+1], 0, length); |
| classpath[length] = createSourceEntry("P2", "/P1", "+**/p/|-**/*"); |
| p2.setRawClasspath(classpath, null); |
| setUpWorkingCopy("/P2/src/Y.java", "public class Y extends p.X {}"); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "----------\n" |
| ); |
| |
| // remove accessible rule |
| System.arraycopy(classpath, 0, classpath = new IClasspathEntry[length+1], 0, length); |
| classpath[length] = createSourceEntry("P2", "/P1", "-**/*"); |
| p2.setRawClasspath(classpath, null); |
| this.problemRequestor.initialize(this.workingCopy.getSource().toCharArray()); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, true/*force problem detection*/, null, null); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "1. ERROR in /P2/src/Y.java (at line 1)\n" + |
| " public class Y extends p.X {}\n" + |
| " ^^^\n" + |
| "Access restriction: The type X is not accessible due to restriction on required project P1\n" + |
| "----------\n" |
| ); |
| |
| } finally { |
| deleteProjects(new String[] {"P1", "P2"}); |
| } |
| } |
| /** |
| * Ensures that the reconciler handles duplicate members correctly. |
| */ |
| public void testAddDuplicateMember() throws JavaModelException { |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " public void foo() {\n" + |
| " }\n" + |
| " public void foo() {\n" + |
| " }\n" + |
| "}"); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected delta", |
| "X[*]: {CHILDREN | FINE GRAINED}\n" + |
| " foo()#2[+]: {}" |
| ); |
| } |
| /** |
| * Ensures that the reconciler reconciles the new contents with the current |
| * contents, updating the structure of this reconciler's compilation |
| * unit, and fires the Java element delta for the structural changes |
| * of the addition of a field and a constructor. |
| */ |
| public void testAddFieldAndConstructor() throws JavaModelException { |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " int i;\n" + |
| " X(int i) {\n" + |
| " this.i = i;\n" + |
| " }\n" + |
| " public void foo() {\n" + |
| " }\n" + |
| "}"); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected delta", |
| "X[*]: {CHILDREN | FINE GRAINED}\n" + |
| " i[+]: {}\n" + |
| " X(int)[+]: {}" |
| ); |
| } |
| /** |
| * Ensures that the reconciler reconciles the new contents with the current |
| * contents, updating the structure of this reconciler's compilation |
| * unit, and fires the Java element delta for the structural changes |
| * of the addition of a field and a constructor. |
| */ |
| public void testAddImports() throws JavaModelException { |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "import java.lang.reflect.*;\n" + |
| "import java.util.Vector;\n" + |
| "public class X {\n" + |
| " public void foo() {\n" + |
| " }\n" + |
| "}"); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected delta", |
| "<import container>[*]: {CHILDREN | FINE GRAINED}\n" + |
| " import java.lang.reflect.*[+]: {}\n" + |
| " import java.util.Vector[+]: {}" |
| ); |
| } |
| /** |
| * Ensures that the reconciler reconciles the new contents with the current |
| * contents, updating the structure of this reconciler's compilation |
| * unit, and fires the Java element delta for the structural changes |
| * of the addition of a method. |
| */ |
| public void testAddMethod1() throws JavaModelException { |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " public void foo() {\n" + |
| " }\n" + |
| " public void bar() {\n" + |
| " }\n" + |
| "}"); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected delta", |
| "X[*]: {CHILDREN | FINE GRAINED}\n" + |
| " bar()[+]: {}" |
| ); |
| } |
| /** |
| * Ensures that the reconciler reconciles the new contents with the current |
| * contents,updating the structure of this reconciler's compilation |
| * unit, and fires the Java element delta for the structural changes |
| * of the addition of a portion of a new method. |
| */ |
| public void testAddPartialMethod1() throws JavaModelException { |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " public void some()\n" + |
| " public void foo() {\n" + |
| " }\n" + |
| "}"); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected delta", |
| "X[*]: {CHILDREN | FINE GRAINED}\n" + |
| " some()[+]: {}" |
| ); |
| } |
| /** |
| * Ensures that the reconciler reconciles the new contents with the current |
| * contents,updating the structure of this reconciler's compilation |
| * unit, and fires the Java element delta for the structural changes |
| * of the addition of a portion of a new method. Ensures that when a |
| * second part is added to the new method no structural changes are recognized. |
| */ |
| public void testAddPartialMethod1and2() throws JavaModelException { |
| // Add partial method before foo |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " public void some()\n" + |
| " public void foo() {\n" + |
| " }\n" + |
| "}"); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| |
| // Add { on partial method |
| clearDeltas(); |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " public void some() {\n" + |
| " public void foo() {\n" + |
| " }\n" + |
| "}"); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected delta", |
| "[Working copy] X.java[*]: {CONTENT | FINE GRAINED}" |
| ); |
| } |
| /* |
| * Ensures that the AST broadcasted during a reconcile operation is correct. |
| * (case of a working copy being reconciled with changes, creating AST and no problem detection) |
| */ |
| public void testBroadcastAST1() throws JavaModelException { |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| "}"); |
| this.workingCopy.reconcile(AST.JLS3, false/*don't force problem detection*/, null/*primary owner*/, null/*no progress*/); |
| assertASTNodeEquals( |
| "Unexpected ast", |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| "}\n", |
| this.deltaListener.getCompilationUnitAST(this.workingCopy)); |
| } |
| /* |
| * Ensures that the AST broadcasted during a reconcile operation is correct. |
| * (case of a working copy being reconciled with NO changes, creating AST and forcing problem detection) |
| */ |
| public void testBroadcastAST2() throws JavaModelException { |
| this.workingCopy.reconcile(AST.JLS3, true/*force problem detection*/, null/*primary owner*/, null/*no progress*/); |
| assertASTNodeEquals( |
| "Unexpected ast", |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " public void foo(){\n" + |
| " }\n" + |
| "}\n", |
| this.deltaListener.getCompilationUnitAST(this.workingCopy)); |
| } |
| /* |
| * Ensures that the AST broadcasted during a reconcile operation is correct. |
| * (case of a working copy being reconciled with NO changes, creating AST and no problem detection) |
| */ |
| public void testBroadcastAST3() throws JavaModelException { |
| this.workingCopy.reconcile(AST.JLS3, false/*don't force problem detection*/, null/*primary owner*/, null/*no progress*/); |
| assertASTNodeEquals( |
| "Unexpected ast", |
| "null", |
| this.deltaListener.getCompilationUnitAST(this.workingCopy)); |
| } |
| /* |
| * Ensures that the AST broadcasted during a reconcile operation is correct. |
| * (case of a working copy being reconciled twice in a batch operation) |
| */ |
| public void testBroadcastAST4() throws CoreException { |
| JavaCore.run( |
| new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| ReconcilerTests.this.workingCopy.reconcile(AST.JLS3, true/*force problem detection*/, null/*primary owner*/, monitor); |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| "}"); |
| ReconcilerTests.this.workingCopy.reconcile(AST.JLS3, false/*don't force problem detection*/, null/*primary owner*/, monitor); |
| } |
| }, |
| null/*no progress*/); |
| assertASTNodeEquals( |
| "Unexpected ast", |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| "}\n", |
| this.deltaListener.getCompilationUnitAST(this.workingCopy)); |
| } |
| /* |
| * Ensures that reconciling a subclass doesn't close the buffer while resolving its superclass. |
| * (regression test for bug 62854 refactoring does not trigger reconcile) |
| */ |
| public void testBufferOpenAfterReconcile() throws CoreException { |
| try { |
| createFile( |
| "/Reconciler/src/p1/Super.java", |
| "package p1;\n" + |
| "public class Super {\n" + |
| "}" |
| ); |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X extends Super {\n" + |
| " public void foo() {\n" + |
| " }\n" + |
| "}"); |
| IBuffer buffer = this.workingCopy.getBuffer(); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, true, null, null); |
| assertTrue("Buffer should still be open", !buffer.isClosed()); |
| } finally { |
| deleteFile("/Reconciler/src/p1/Super.java"); |
| } |
| } |
| /** |
| * Ensure an OperationCanceledException is correcly thrown when progress monitor is canceled |
| * @deprecated using deprecated code |
| */ |
| public void testCancel() throws JavaModelException { |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "public class X {\n" + |
| " void foo(String s) {\n" + |
| " }\n" + |
| "}" |
| ); |
| this.workingCopy.makeConsistent(null); |
| |
| // count the number of time isCanceled() is called when converting this source unit |
| CancelCounter counter = new CancelCounter(); |
| this.workingCopy.reconcile(AST.JLS2, true, null, counter); |
| |
| // throw an OperatonCanceledException at each point isCanceled() is called |
| for (int i = 0; i < counter.count; i++) { |
| boolean gotException = false; |
| try { |
| this.workingCopy.reconcile(AST.JLS2, true, null, new Canceler(i)); |
| } catch (OperationCanceledException e) { |
| gotException = true; |
| } |
| assertTrue("Should get an OperationCanceledException (" + i + ")", gotException); |
| } |
| |
| // last should not throw an OperationCanceledException |
| this.workingCopy.reconcile(AST.JLS2, true, null, new Canceler(counter.count)); |
| } |
| /** |
| * Ensures that the delta is correct when adding a category |
| */ |
| public void testCategories1() throws JavaModelException { |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " /**\n" + |
| " * @category cat1\n" + |
| " */\n" + |
| " public void foo() {\n" + |
| " }\n" + |
| "}" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected delta", |
| "X[*]: {CHILDREN | FINE GRAINED}\n" + |
| " foo()[*]: {CATEGORIES}" |
| ); |
| } |
| /** |
| * Ensures that the delta is correct when removing a category |
| */ |
| public void testCategories2() throws JavaModelException { |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " /**\n" + |
| " * @category cat1\n" + |
| " */\n" + |
| " public void foo() {\n" + |
| " }\n" + |
| "}" |
| ); |
| this.workingCopy.makeConsistent(null); |
| |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " public void foo() {\n" + |
| " }\n" + |
| "}" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected delta", |
| "X[*]: {CHILDREN | FINE GRAINED}\n" + |
| " foo()[*]: {CATEGORIES}" |
| ); |
| } |
| /** |
| * Ensures that the delta is correct when changing a category |
| */ |
| public void testCategories3() throws JavaModelException { |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " /**\n" + |
| " * @category cat1\n" + |
| " */\n" + |
| " public void foo() {\n" + |
| " }\n" + |
| "}" |
| ); |
| this.workingCopy.makeConsistent(null); |
| |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " /**\n" + |
| " * @category cat2\n" + |
| " */\n" + |
| " public void foo() {\n" + |
| " }\n" + |
| "}" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected delta", |
| "X[*]: {CHILDREN | FINE GRAINED}\n" + |
| " foo()[*]: {CATEGORIES}" |
| ); |
| } |
| /** |
| * Ensures that the reconciler reconciles the new contents with the current |
| * contents,updating the structure of this reconciler's compilation |
| * unit, and fires the Java element deltas for the structural changes |
| * of a method's type parameter change. |
| */ |
| public void testChangeMethodTypeParameters() throws JavaModelException { |
| setUp15WorkingCopy(); |
| clearDeltas(); |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " public <T> void foo() {\n" + |
| " }\n" + |
| "}"); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected delta", |
| "X[*]: {CHILDREN | FINE GRAINED}\n" + |
| " foo()[*]: {CONTENT}" |
| ); |
| } |
| /** |
| * Ensures that the reconciler reconciles the new contents with the current |
| * contents,updating the structure of this reconciler's compilation |
| * unit, and fires the Java element deltas for the structural changes |
| * of a type's type parameter change. |
| */ |
| public void testChangeTypeTypeParameters() throws JavaModelException { |
| setUp15WorkingCopy(); |
| clearDeltas(); |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X <T> {\n" + |
| " public void foo() {\n" + |
| " }\n" + |
| "}"); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected delta", |
| "X[*]: {CONTENT}" |
| ); |
| } |
| /** |
| * Ensures that the reconciler reconciles the new contents with the current |
| * contents,updating the structure of this reconciler's compilation |
| * unit, and fires the Java element deltas for the structural changes |
| * of a method visibility change. |
| */ |
| public void testChangeMethodVisibility() throws JavaModelException { |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " private void foo() {\n" + |
| " }\n" + |
| "}"); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected delta", |
| "X[*]: {CHILDREN | FINE GRAINED}\n" + |
| " foo()[*]: {MODIFIERS CHANGED}" |
| ); |
| } |
| /** |
| * Ensures that the correct delta is reported when closing the working copy and modifying its buffer. |
| */ |
| public void testCloseWorkingCopy() throws JavaModelException { |
| IBuffer buffer = this.workingCopy.getBuffer(); |
| this.workingCopy.close(); |
| buffer.setContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " public void foo() {\n" + |
| " }\n" + |
| " public void bar() {\n" + |
| " }\n" + |
| "}"); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected delta", |
| "X[*]: {CHILDREN | FINE GRAINED}\n" + |
| " bar()[+]: {}" |
| ); |
| } |
| |
| /** |
| * Ensures that a reference to a constant with type mismatch doesn't show an error. |
| * (regression test for bug 17104 Compiler does not complain but "Quick Fix" ??? complains) |
| */ |
| public void testConstantReference() throws CoreException { |
| try { |
| createFile( |
| "/Reconciler/src/p1/OS.java", |
| "package p1;\n" + |
| "public class OS {\n" + |
| " public static final int CONST = 23 * 1024;\n" + |
| "}"); |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "public class X {\n" + |
| " public short c;\n" + |
| " public static void main(String[] arguments) {\n" + |
| " short c = 1;\n" + |
| " switch (c) {\n" + |
| " case OS.CONST: return;\n" + |
| " }\n" + |
| " }\n" + |
| "}"); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "----------\n" |
| ); |
| } finally { |
| deleteFile("/Reconciler/src/p1/OS.java"); |
| } |
| } |
| /** |
| * Ensures that the reconciler reconciles the new contents with the current |
| * contents, updating the structure of this reconciler's compilation |
| * unit, and fires the Java element deltas for the structural changes |
| * of a method being deleted. |
| */ |
| public void testDeleteMethod1() throws JavaModelException { |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| "}"); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected delta", |
| "X[*]: {CHILDREN | FINE GRAINED}\n" + |
| " foo()[-]: {}" |
| ); |
| } |
| /** |
| * Ensures that the reconciler reconciles the new contents with the current |
| * contents, updating the structure of this reconciler's compilation |
| * unit, and fires the Java element deltas for the structural changes |
| * of two methods being deleted. |
| */ |
| public void testDeleteTwoMethods() throws JavaModelException { |
| // create 2 methods |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " public void foo() {\n" + |
| " }\n" + |
| " public void bar() {\n" + |
| " }\n" + |
| "}"); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| |
| // delete the 2 methods |
| clearDeltas(); |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| "}"); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected delta", |
| "X[*]: {CHILDREN | FINE GRAINED}\n" + |
| " bar()[-]: {}\n" + |
| " foo()[-]: {}" |
| ); |
| } |
| /* |
| * Ensures that excluded part of prereq project are not visible |
| */ |
| public void testExcludePartOfAnotherProject1() throws CoreException { |
| IClasspathEntry[] newEntries = createClasspath("Reconciler", new String[] {"/P", "-**/internal/"}); |
| try { |
| addClasspathEntries(newEntries, true); |
| createJavaProject("P"); |
| createFolder("/P/p/internal"); |
| createFile( |
| "/P/p/internal/Y.java", |
| "package p.internal;\n" + |
| "public class Y {\n" + |
| "}" |
| ); |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "public class X extends p.internal.Y {\n" + |
| "}" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "1. ERROR in /Reconciler/src/p1/X.java (at line 2)\n" + |
| " public class X extends p.internal.Y {\n" + |
| " ^^^^^^^^^^^^\n" + |
| "Access restriction: The type Y is not accessible due to restriction on required project P\n" + |
| "----------\n" |
| ); |
| } finally { |
| removeClasspathEntries(newEntries); |
| deleteProject("P"); |
| } |
| } |
| /* |
| * Ensures that packages that are not in excluded part of prereq project are visible |
| */ |
| public void testExcludePartOfAnotherProject2() throws CoreException { |
| IClasspathEntry[] newEntries = createClasspath("Reconciler", new String[] {"/P", "-**/internal/"}); |
| try { |
| addClasspathEntries(newEntries, true); |
| createJavaProject("P"); |
| createFolder("/P/p/api"); |
| createFile( |
| "/P/p/api/Y.java", |
| "package p.api;\n" + |
| "public class Y {\n" + |
| "}" |
| ); |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "public class X extends p.api.Y {\n" + |
| "}" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "----------\n" |
| ); |
| } finally { |
| removeClasspathEntries(newEntries); |
| deleteProject("P"); |
| } |
| } |
| /* |
| * Ensures that included part of prereq project are visible |
| */ |
| public void testIncludePartOfAnotherProject1() throws CoreException { |
| IClasspathEntry[] newEntries = createClasspath("Reconciler", new String[] {"/P", "+**/api/"}); |
| try { |
| addClasspathEntries(newEntries, true); |
| createJavaProject("P"); |
| createFolder("/P/p/api"); |
| createFile( |
| "/P/p/api/Y.java", |
| "package p.api;\n" + |
| "public class Y {\n" + |
| "}" |
| ); |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "public class X extends p.api.Y {\n" + |
| "}" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "----------\n" |
| ); |
| } finally { |
| removeClasspathEntries(newEntries); |
| deleteProject("P"); |
| } |
| } |
| /* |
| * Ensures that packages that are not in included part of prereq project are not visible |
| */ |
| public void testIncludePartOfAnotherProject2() throws CoreException { |
| IClasspathEntry[] newEntries = createClasspath("Reconciler", new String[] {"/P", "+**/api/|-**"}); |
| try { |
| addClasspathEntries(newEntries, true); |
| createJavaProject("P"); |
| createFolder("/P/p/internal"); |
| createFile( |
| "/P/p/internal/Y.java", |
| "package p.internal;\n" + |
| "public class Y {\n" + |
| "}" |
| ); |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "public class X extends p.internal.Y {\n" + |
| "}" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "1. ERROR in /Reconciler/src/p1/X.java (at line 2)\n" + |
| " public class X extends p.internal.Y {\n" + |
| " ^^^^^^^^^^^^\n" + |
| "Access restriction: The type Y is not accessible due to restriction on required project P\n" + |
| "----------\n" |
| ); |
| } finally { |
| removeClasspathEntries(newEntries); |
| deleteProject("P"); |
| } |
| } |
| /** |
| * Start with no imports, add an import, and then append to the import name. |
| */ |
| public void testGrowImports() throws JavaModelException { |
| // no imports |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "public class X {\n" + |
| "}"); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| |
| // add an import |
| clearDeltas(); |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p\n" + |
| "public class X {\n" + |
| "}"); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected delta", |
| "<import container>[+]: {}" |
| ); |
| |
| // append to import name |
| clearDeltas(); |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2\n" + |
| "public class X {\n" + |
| "}"); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected delta", |
| "<import container>[*]: {CHILDREN | FINE GRAINED}\n" + |
| " import p2[+]: {}\n" + |
| " import p[-]: {}" |
| ); |
| } |
| /** |
| * Introduces a syntax error in the modifiers of a method. |
| */ |
| public void testMethodWithError01() throws CoreException { |
| // Introduce syntax error |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " public.void foo() {\n" + |
| " }\n" + |
| "}"); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected delta after syntax error", |
| "X[*]: {CHILDREN | FINE GRAINED}\n" + |
| " foo()[*]: {MODIFIERS CHANGED}" |
| ); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "1. ERROR in /Reconciler/src/p1/X.java (at line 4)\n" + |
| " public.void foo() {\n" + |
| " ^\n" + |
| "Syntax error on token \".\", delete this token\n" + |
| "----------\n" |
| ); |
| |
| // Fix the syntax error |
| clearDeltas(); |
| String contents = |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " public void foo() {\n" + |
| " }\n" + |
| "}"; |
| setWorkingCopyContents(contents); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected delta after fixing syntax error", |
| "X[*]: {CHILDREN | FINE GRAINED}\n" + |
| " foo()[*]: {MODIFIERS CHANGED}" |
| ); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "1. WARNING in /Reconciler/src/p1/X.java (at line 2)\n" + |
| " import p2.*;\n" + |
| " ^^\n" + |
| "The import p2 is never used\n" + |
| "----------\n" |
| ); |
| } |
| /** |
| * Test reconcile force flag |
| */ |
| public void testMethodWithError02() throws CoreException { |
| String contents = |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " public.void foo() {\n" + |
| " }\n" + |
| "}"; |
| setWorkingCopyContents(contents); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| |
| // use force flag to refresh problems |
| this.problemRequestor.initialize(contents.toCharArray()); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, true, null, null); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "1. ERROR in /Reconciler/src/p1/X.java (at line 4)\n" + |
| " public.void foo() {\n" + |
| " ^\n" + |
| "Syntax error on token \".\", delete this token\n" + |
| "----------\n" |
| ); |
| } |
| |
| /** |
| * Test reconcile force flag off |
| */ |
| public void testMethodWithError03() throws CoreException { |
| String contents = |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " public.void foo() {\n" + |
| " }\n" + |
| "}"; |
| setWorkingCopyContents(contents); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| |
| // reconcile with force flag turned off |
| this.problemRequestor.initialize(contents.toCharArray()); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertProblems( |
| "Unexpected problems", |
| "" |
| ); |
| } |
| /** |
| * Test reconcile force flag + cancel |
| */ |
| public void testMethodWithError04() throws CoreException { |
| |
| CancelingProblemRequestor myPbRequestor = new CancelingProblemRequestor(); |
| |
| this.workingCopy.discardWorkingCopy(); |
| ICompilationUnit x = getCompilationUnit("Reconciler", "src", "p1", "X.java"); |
| this.problemRequestor = myPbRequestor; |
| this.workingCopy = x.getWorkingCopy(new WorkingCopyOwner() {}, this.problemRequestor, null); |
| |
| String contents = |
| "package p1;\n" + |
| "public class X {\n" + |
| " Zork f; \n"+ |
| " void foo(Zork z){\n"+ |
| " }\n"+ |
| "} \n"; |
| setWorkingCopyContents(contents); |
| |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| |
| // use force flag to refresh problems |
| myPbRequestor.isCanceling = true; |
| myPbRequestor.initialize(contents.toCharArray()); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, true, null, myPbRequestor.progressMonitor); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "1. ERROR in /Reconciler/src/p1/X.java (at line 3)\n" + |
| " Zork f; \n" + |
| " ^^^^\n" + |
| "Zork cannot be resolved to a type\n" + |
| "----------\n" |
| ); |
| } |
| |
| /** |
| * Test reconcile force flag off |
| */ |
| public void testMethodWithError05() throws CoreException { |
| try { |
| createFolder("/Reconciler/src/tests"); |
| String contents = |
| "package tests; \n"+ |
| "abstract class AbstractSearchableSource extends AbstractSource implements SearchableSource { \n"+ |
| " abstract int indexOfImpl(long value); \n"+ |
| " public final int indexOf(long value) { \n"+ |
| " return indexOfImpl(value); \n"+ |
| " } \n"+ |
| "} \n"; |
| createFile( |
| "/Reconciler/src/tests/AbstractSearchableSource.java", |
| contents); |
| |
| createFile( |
| "/Reconciler/src/tests/Source.java", |
| "package tests; \n"+ |
| "interface Source { \n"+ |
| " long getValue(int index); \n"+ |
| " int size(); \n"+ |
| "} \n"); |
| |
| createFile( |
| "/Reconciler/src/tests/AbstractSource.java", |
| "package tests; \n"+ |
| "abstract class AbstractSource implements Source { \n"+ |
| " AbstractSource() { \n"+ |
| " } \n"+ |
| " void invalidate() { \n"+ |
| " } \n"+ |
| " abstract long getValueImpl(int index); \n"+ |
| " abstract int sizeImpl(); \n"+ |
| " public final long getValue(int index) { \n"+ |
| " return 0; \n"+ |
| " } \n"+ |
| " public final int size() { \n"+ |
| " return 0; \n"+ |
| " } \n"+ |
| "} \n"); |
| |
| createFile( |
| "/Reconciler/src/tests/SearchableSource.java", |
| "package tests; \n"+ |
| "interface SearchableSource extends Source { \n"+ |
| " int indexOf(long value); \n"+ |
| "} \n"); |
| |
| ICompilationUnit compilationUnit = getCompilationUnit("Reconciler", "src", "tests", "AbstractSearchableSource.java"); |
| ProblemRequestor pbReq = new ProblemRequestor(); |
| ICompilationUnit wc = compilationUnit.getWorkingCopy(new WorkingCopyOwner() {}, pbReq, null); |
| pbReq.initialize(contents.toCharArray()); |
| startDeltas(); |
| wc.reconcile(ICompilationUnit.NO_AST, true, null, null); |
| String actual = pbReq.problems.toString(); |
| String expected = |
| "----------\n" + |
| "----------\n"; |
| if (!expected.equals(actual)){ |
| System.out.println(Util.displayString(actual, 2)); |
| } |
| assertEquals( |
| "unexpected errors", |
| expected, |
| actual); |
| } finally { |
| deleteFile("/Reconciler/src/tests/AbstractSearchableSource.java"); |
| deleteFile("/Reconciler/src/tests/SearchableSource.java"); |
| deleteFile("/Reconciler/src/tests/Source.java"); |
| deleteFile("/Reconciler/src/tests/AbstractSource.java"); |
| deleteFolder("/Reconciler/src/tests"); |
| } |
| } |
| /* |
| * Test that the creation of a working copy detects errors |
| * (regression test for bug 33757 Problem not detected when opening a working copy) |
| */ |
| public void testMethodWithError06() throws CoreException { |
| this.workingCopy.discardWorkingCopy(); // don't use the one created in setUp() |
| this.workingCopy = null; |
| try { |
| String contents = |
| "package p1;\n" + |
| "public class Y {\n" + |
| " public.void foo() {\n" + |
| " }\n" + |
| "}"; |
| createFile( |
| "/Reconciler/src/p1/Y.java", |
| contents |
| ); |
| this.problemRequestor = new ProblemRequestor(); |
| this.problemRequestor.initialize(contents.toCharArray()); |
| this.workingCopy = getCompilationUnit("Reconciler/src/p1/Y.java").getWorkingCopy(new WorkingCopyOwner() {}, this.problemRequestor, null); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "1. ERROR in /Reconciler/src/p1/Y.java (at line 3)\n" + |
| " public.void foo() {\n" + |
| " ^\n" + |
| "Syntax error on token \".\", delete this token\n" + |
| "----------\n" |
| ); |
| } finally { |
| deleteFile("/Reconciler/src/p1/Y.java"); |
| } |
| } |
| /* |
| * Test that the opening of a working copy detects errors |
| * (regression test for bug 33757 Problem not detected when opening a working copy) |
| */ |
| public void testMethodWithError07() throws CoreException { |
| this.workingCopy.discardWorkingCopy(); // don't use the one created in setUp() |
| this.workingCopy = null; |
| try { |
| String contents = |
| "package p1;\n" + |
| "public class Y {\n" + |
| " public.void foo() {\n" + |
| " }\n" + |
| "}"; |
| createFile( |
| "/Reconciler/src/p1/Y.java", |
| contents |
| ); |
| this.problemRequestor = new ProblemRequestor(); |
| this.problemRequestor.initialize(contents.toCharArray()); |
| this.workingCopy = getCompilationUnit("Reconciler/src/p1/Y.java").getWorkingCopy(new WorkingCopyOwner() {}, this.problemRequestor, null); |
| |
| // Close working copy |
| JavaModelManager.getJavaModelManager().removeInfoAndChildren((CompilationUnit)workingCopy); // use a back door as working copies cannot be closed |
| |
| // Reopen should detect syntax error |
| this.problemRequestor.initialize(contents.toCharArray()); |
| this.workingCopy.open(null); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "1. ERROR in /Reconciler/src/p1/Y.java (at line 3)\n" + |
| " public.void foo() {\n" + |
| " ^\n" + |
| "Syntax error on token \".\", delete this token\n" + |
| "----------\n" |
| ); |
| } finally { |
| deleteFile("/Reconciler/src/p1/Y.java"); |
| } |
| } |
| /* |
| * Test that the units with similar names aren't presenting each other errors |
| * (regression test for bug 39475) |
| */ |
| public void testMethodWithError08() throws CoreException { |
| this.workingCopy.discardWorkingCopy(); // don't use the one created in setUp() |
| this.workingCopy = null; |
| try { |
| createFile( |
| "/Reconciler/src/p1/X01.java", |
| "package p1;\n" + |
| "public abstract class X01 {\n" + |
| " public abstract void bar(); \n"+ |
| " public abstract void foo(Zork z); \n"+ |
| "}" |
| ); |
| String contents = |
| "package p2;\n" + |
| "public class X01 extends p1.X01 {\n" + |
| " public void bar(){} \n"+ |
| "}"; |
| createFile( |
| "/Reconciler/src/p2/X01.java", |
| contents |
| ); |
| this.problemRequestor = new ProblemRequestor(); |
| this.problemRequestor.initialize(contents.toCharArray()); |
| this.workingCopy = getCompilationUnit("Reconciler/src/p2/X01.java").getWorkingCopy(new WorkingCopyOwner() {}, this.problemRequestor, null); |
| |
| // Close working copy |
| JavaModelManager.getJavaModelManager().removeInfoAndChildren((CompilationUnit)workingCopy); // use a back door as working copies cannot be closed |
| |
| // Reopen should detect syntax error |
| this.problemRequestor.initialize(contents.toCharArray()); |
| this.workingCopy.open(null); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "----------\n" // shouldn't report problem against p2.X01 |
| ); |
| } finally { |
| deleteFile("/Reconciler/src/p1/X01.java"); |
| deleteFile("/Reconciler/src/p2/X01.java"); |
| } |
| } |
| /* |
| * Scenario of reconciling using a working copy owner |
| */ |
| public void testMethodWithError09() throws CoreException { |
| this.workingCopy.discardWorkingCopy(); // don't use the one created in setUp() |
| this.workingCopy = null; |
| WorkingCopyOwner owner = new WorkingCopyOwner() {}; |
| ICompilationUnit workingCopy1 = null; |
| try { |
| workingCopy1 = getCompilationUnit("/Reconciler/src/p1/X1.java").getWorkingCopy(owner, null, null); |
| workingCopy1.getBuffer().setContents( |
| "package p1;\n" + |
| "public abstract class X1 {\n" + |
| " public abstract void bar(); \n"+ |
| "}" |
| ); |
| workingCopy1.makeConsistent(null); |
| |
| this.problemRequestor = new ProblemRequestor(); |
| this.workingCopy = getCompilationUnit("Reconciler/src/p/X.java").getWorkingCopy(owner, this.problemRequestor, null); |
| setWorkingCopyContents( |
| "package p;\n" + |
| "public class X extends p1.X1 {\n" + |
| " public void bar(){} \n"+ |
| "}" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, owner, null); |
| |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "----------\n" // shouldn't report problem against p.X |
| ); |
| } finally { |
| if (workingCopy1 != null) { |
| workingCopy1.discardWorkingCopy(); |
| } |
| } |
| } |
| /* |
| * Scenario of reconciling using a working copy owner (68557) |
| */ |
| public void testMethodWithError10() throws CoreException { |
| this.workingCopy.discardWorkingCopy(); // don't use the one created in setUp() |
| this.workingCopy = null; |
| WorkingCopyOwner owner = new WorkingCopyOwner() {}; |
| ICompilationUnit workingCopy1 = null; |
| try { |
| createFolder("/Reconciler15/src/test/cheetah"); |
| workingCopy1 = getCompilationUnit("/Reconciler15/src/test/cheetah/NestedGenerics.java").getWorkingCopy(owner, null, null); |
| workingCopy1.getBuffer().setContents( |
| "package test.cheetah;\n"+ |
| "import java.util.List;\n"+ |
| "import java.util.Stack;\n"+ |
| "public class NestedGenerics {\n"+ |
| " Stack< List<Object>> stack = new Stack< List<Object> >();\n"+ |
| "}\n" |
| ); |
| workingCopy1.makeConsistent(null); |
| |
| this.problemRequestor = new ProblemRequestor(); |
| this.workingCopy = getCompilationUnit("Reconciler15/src/test/cheetah/NestedGenericsTest.java").getWorkingCopy(owner, this.problemRequestor, null); |
| setWorkingCopyContents( |
| "package test.cheetah;\n"+ |
| "import java.util.Stack;\n"+ |
| "public class NestedGenericsTest {\n"+ |
| " void test() { \n"+ |
| " Stack s = new NestedGenerics().stack; \n"+ |
| " }\n"+ |
| "}\n" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, owner, null); |
| |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "----------\n" |
| ); |
| } finally { |
| if (workingCopy1 != null) { |
| workingCopy1.discardWorkingCopy(); |
| } |
| deleteFolder("/Reconciler15/src/test"); |
| } |
| } |
| /* |
| * Scenario of reconciling using a working copy owner (68557) |
| */ |
| public void testMethodWithError11() throws CoreException { |
| this.workingCopy.discardWorkingCopy(); // don't use the one created in setUp() |
| this.workingCopy = null; |
| WorkingCopyOwner owner = new WorkingCopyOwner() {}; |
| ICompilationUnit workingCopy1 = null; |
| try { |
| createFolder("/Reconciler15/src/test/cheetah"); |
| workingCopy1 = getCompilationUnit("/Reconciler15/src/test/cheetah/NestedGenerics.java").getWorkingCopy(owner, null, null); |
| workingCopy1.getBuffer().setContents( |
| "package test.cheetah;\n"+ |
| "import java.util.*;\n"+ |
| "public class NestedGenerics {\n"+ |
| " Map<List<Object>,String> map = null;\n"+ |
| " Stack<List<Object>> stack2 = null;\n"+ |
| " Map<List<Object>,List<Object>> map3 = null;\n"+ |
| "}\n" |
| ); |
| workingCopy1.makeConsistent(null); |
| |
| this.problemRequestor = new ProblemRequestor(); |
| this.workingCopy = getCompilationUnit("Reconciler15/src/test/cheetah/NestedGenericsTest.java").getWorkingCopy(owner, this.problemRequestor, null); |
| setWorkingCopyContents( |
| "package test.cheetah;\n"+ |
| "import java.util.*;\n"+ |
| "public class NestedGenericsTest {\n"+ |
| " void test() { \n"+ |
| " Map m = new NestedGenerics().map; \n"+ |
| " Stack s2 = new NestedGenerics().stack2; \n"+ |
| " Map m3 = new NestedGenerics().map3; \n"+ |
| " }\n"+ |
| "}\n" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, owner, null); |
| |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "----------\n" |
| ); |
| } finally { |
| if (workingCopy1 != null) { |
| workingCopy1.discardWorkingCopy(); |
| } |
| deleteFolder("/Reconciler15/src/test"); |
| } |
| } |
| /* |
| * Scenario of reconciling using a working copy owner (68557 variation with wildcards) |
| */ |
| public void testMethodWithError12() throws CoreException { |
| this.workingCopy.discardWorkingCopy(); // don't use the one created in setUp() |
| this.workingCopy = null; |
| WorkingCopyOwner owner = new WorkingCopyOwner() {}; |
| ICompilationUnit workingCopy1 = null; |
| try { |
| createFolder("/Reconciler15/src/test/cheetah"); |
| workingCopy1 = getCompilationUnit("/Reconciler15/src/test/cheetah/NestedGenerics.java").getWorkingCopy(owner, null, null); |
| workingCopy1.getBuffer().setContents( |
| "package test.cheetah;\n"+ |
| "import java.util.*;\n"+ |
| "public class NestedGenerics {\n"+ |
| " Map<List<?>,? super String> map = null;\n"+ |
| " Stack<List<? extends Object>> stack2 = null;\n"+ |
| " Map<List<Object[]>,List<Object>[]> map3 = null;\n"+ |
| "}\n" |
| ); |
| workingCopy1.makeConsistent(null); |
| |
| this.problemRequestor = new ProblemRequestor(); |
| this.workingCopy = getCompilationUnit("Reconciler15/src/test/cheetah/NestedGenericsTest.java").getWorkingCopy(owner, this.problemRequestor, null); |
| setWorkingCopyContents( |
| "package test.cheetah;\n"+ |
| "import java.util.*;\n"+ |
| "public class NestedGenericsTest {\n"+ |
| " void test() { \n"+ |
| " Map m = new NestedGenerics().map; \n"+ |
| " Stack s2 = new NestedGenerics().stack2; \n"+ |
| " Map m3 = new NestedGenerics().map3; \n"+ |
| " }\n"+ |
| "}\n" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, owner, null); |
| |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "----------\n" |
| ); |
| } finally { |
| if (workingCopy1 != null) { |
| workingCopy1.discardWorkingCopy(); |
| } |
| deleteFolder("/Reconciler15/src/test"); |
| } |
| } |
| /* |
| * Scenario of reconciling using a working copy owner (68730) |
| */ |
| public void testMethodWithError13() throws CoreException { |
| this.workingCopy.discardWorkingCopy(); // don't use the one created in setUp() |
| this.workingCopy = null; |
| WorkingCopyOwner owner = new WorkingCopyOwner() {}; |
| ICompilationUnit workingCopy1 = null; |
| try { |
| workingCopy1 = getCompilationUnit("/Reconciler15/src/test/X.java").getWorkingCopy(owner, null, null); |
| createFolder("/Reconciler15/src/test"); |
| workingCopy1.getBuffer().setContents( |
| "package test;\n"+ |
| "public class X <T extends String, U> {\n"+ |
| " <Y1> void bar(Y1[] y) {}\n"+ |
| " void bar2(Y<E3[]>[] ye[]) {}\n"+ |
| " void foo(java.util.Map<Object[],String>.MapEntry<p.K<T>[],? super q.r.V8> m){}\n"+ |
| " Class<? extends Object> getClass0() {}\n"+ |
| " <E extends String> void pair (X<? extends E, U> e, T t){}\n"+ |
| "}\n" |
| ); |
| workingCopy1.makeConsistent(null); |
| |
| this.problemRequestor = new ProblemRequestor(); |
| this.workingCopy = getCompilationUnit("Reconciler15/src/test/Y.java").getWorkingCopy(owner, this.problemRequestor, null); |
| setWorkingCopyContents( |
| "package test;\n"+ |
| "public class Y {\n"+ |
| " void foo(){\n"+ |
| " X someX = new X();\n"+ |
| " someX.bar(null);\n"+ |
| " }\n"+ |
| "}\n" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, owner, null); |
| |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "1. WARNING in /Reconciler15/src/test/Y.java (at line 5)\n" + |
| " someX.bar(null);\n" + |
| " ^^^^^^^^^^^^^^^\n" + |
| "Type safety: The method bar(Object[]) belongs to the raw type X. References to generic type X<T,U> should be parameterized\n" + |
| "----------\n" |
| ); |
| } finally { |
| if (workingCopy1 != null) { |
| workingCopy1.discardWorkingCopy(); |
| } |
| deleteFolder("/Reconciler15/src/test"); |
| } |
| } |
| /* |
| * Scenario of reconciling using a working copy owner (66424) |
| */ |
| public void testMethodWithError14() throws CoreException { |
| this.workingCopy.discardWorkingCopy(); // don't use the one created in setUp() |
| this.workingCopy = null; |
| WorkingCopyOwner owner = new WorkingCopyOwner() {}; |
| ICompilationUnit workingCopy1 = null; |
| try { |
| workingCopy1 = getCompilationUnit("/Reconciler15/src/test/X.java").getWorkingCopy(owner, null, null); |
| createFolder("/Reconciler15/src/test"); |
| workingCopy1.getBuffer().setContents( |
| "package test;\n"+ |
| "public class X <T> {\n"+ |
| " <U> void bar(U u) {}\n"+ |
| "}\n" |
| ); |
| workingCopy1.makeConsistent(null); |
| |
| this.problemRequestor = new ProblemRequestor(); |
| this.workingCopy = getCompilationUnit("Reconciler15/src/test/Y.java").getWorkingCopy(owner, this.problemRequestor, null); |
| setWorkingCopyContents( |
| "package test;\n"+ |
| "public class Y {\n"+ |
| " void foo(){\n"+ |
| " X someX = new X();\n"+ |
| " someX.bar();\n"+ |
| " }\n"+ |
| "}\n" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, owner, null); |
| |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "1. ERROR in /Reconciler15/src/test/Y.java (at line 5)\n" + |
| " someX.bar();\n" + |
| " ^^^\n" + |
| "The method bar(Object) in the type X is not applicable for the arguments ()\n" + |
| "----------\n" |
| ); |
| } finally { |
| if (workingCopy1 != null) { |
| workingCopy1.discardWorkingCopy(); |
| } |
| deleteFolder("/Reconciler15/src/test"); |
| } |
| } |
| /** |
| * Ensures that the reconciler handles member move correctly. |
| */ |
| public void testMoveMember() throws JavaModelException { |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " public void foo() {\n" + |
| " }\n" + |
| " public void bar() {\n" + |
| " }\n" + |
| "}"); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| clearDeltas(); |
| |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " public void bar() {\n" + |
| " }\n" + |
| " public void foo() {\n" + |
| " }\n" + |
| "}"); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected delta", |
| "X[*]: {CHILDREN | FINE GRAINED}\n" + |
| " bar()[*]: {REORDERED}\n" + |
| " foo()[*]: {REORDERED}" |
| ); |
| } |
| /** |
| * Ensures that the reconciler does nothing when the source |
| * to reconcile with is the same as the current contents. |
| */ |
| public void testNoChanges1() throws JavaModelException { |
| setWorkingCopyContents(this.workingCopy.getSource()); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected delta", |
| "[Working copy] X.java[*]: {CONTENT | FINE GRAINED}" |
| ); |
| } |
| /** |
| * Ensures that the reconciler does nothing when the source |
| * to reconcile with has the same structure as the current contents. |
| */ |
| public void testNoChanges2() throws JavaModelException { |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " public void foo() {\n" + |
| " System.out.println()\n" + |
| " }\n" + |
| "}" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected delta", |
| "[Working copy] X.java[*]: {CONTENT | FINE GRAINED}" |
| ); |
| } |
| /* |
| * Ensures that using a non-generic method with no parametera and with a raw receiver type doesn't create a type safety warning |
| * (regression test for bug 105756 [1.5][model] Incorrect warning on using raw types) |
| */ |
| public void testRawUsage() throws CoreException { |
| ICompilationUnit otherCopy = null; |
| try { |
| WorkingCopyOwner owner = new WorkingCopyOwner() {}; |
| otherCopy = getWorkingCopy( |
| "Reconciler15/src/Generic105756.java", |
| "public class Generic105756<T> {\n" + |
| " void foo() {}\n" + |
| "}", |
| owner, |
| false/*don't compute problems*/); |
| setUp15WorkingCopy("/Reconciler15/src/X.java", owner); |
| setWorkingCopyContents( |
| "public class X {\n" + |
| " void bar(Generic105756 g) {\n" + |
| " g.foo();\n" + |
| " }\n" + |
| "}" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "----------\n" |
| ); |
| } finally { |
| if (otherCopy != null) |
| otherCopy.discardWorkingCopy(); |
| } |
| } |
| /* |
| * Ensures that a reconcile participant is notified when a working copy is reconciled. |
| */ |
| public void testReconcileParticipant01() throws CoreException { |
| ReconcileParticipant participant = new ReconcileParticipant(); |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " public void bar() {\n" + |
| " System.out.println()\n" + |
| " }\n" + |
| "}" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected participant delta", |
| "[Working copy] X.java[*]: {CHILDREN | FINE GRAINED}\n" + |
| " X[*]: {CHILDREN | FINE GRAINED}\n" + |
| " bar()[+]: {}\n" + |
| " foo()[-]: {}", |
| participant.delta |
| ); |
| } |
| /* |
| * Ensures that a reconcile participant is not notified if not participating. |
| */ |
| public void testReconcileParticipant02() throws CoreException { |
| ReconcileParticipant participant = new ReconcileParticipant(){ |
| public boolean isActive(IJavaProject project) { |
| return false; |
| } |
| }; |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " public void bar() {\n" + |
| " System.out.println()\n" + |
| " }\n" + |
| "}" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected participant delta", |
| "<null>", |
| participant.delta |
| ); |
| } |
| /* |
| * Ensures that a reconcile participant is notified with the correct AST. |
| */ |
| public void testReconcileParticipant03() throws CoreException { |
| ReconcileParticipant participant = new ReconcileParticipant(AST.JLS3, false/*don't resolve binding*/); |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " public void bar() {\n" + |
| " System.out.println()\n" + |
| " }\n" + |
| "}" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertASTNodeEquals( |
| "Unexpected participant delta", |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " public void bar(){\n" + |
| " }\n" + |
| "}\n", |
| participant.ast |
| ); |
| } |
| /* |
| * Ensures that the same AST as the one a reconcile participant requested is reported. |
| */ |
| public void testReconcileParticipant04() throws CoreException { |
| ReconcileParticipant participant = new ReconcileParticipant(AST.JLS3, false/*don't resolve binding*/); |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " public void bar() {\n" + |
| " System.out.println()\n" + |
| " }\n" + |
| "}" |
| ); |
| org.eclipse.jdt.core.dom.CompilationUnit ast = this.workingCopy.reconcile(AST.JLS3, false, null, null); |
| assertSame( |
| "Unexpected participant delta", |
| participant.ast, |
| ast |
| ); |
| } |
| /* |
| * Ensures that a participant can fix an error during reconcile. |
| */ |
| public void testReconcileParticipant05() throws CoreException { |
| new ReconcileParticipant(AST.JLS3, true/*resolve binding*/) { |
| public void reconcile(ReconcileContext context) { |
| try { |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "public class X {\n" + |
| " public void bar() {\n" + |
| " }\n" + |
| "}" |
| ); |
| context.resetAST(); |
| } catch (JavaModelException e) { |
| e.printStackTrace(); |
| } |
| } |
| }; |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "public class X {\n" + |
| " public void bar() {\n" + |
| " toString()\n" + |
| " }\n" + |
| "}" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "----------\n" |
| ); |
| } |
| /* |
| * Ensures that a participant can introduce an error during reconcile. |
| */ |
| public void testReconcileParticipant06() throws CoreException { |
| new ReconcileParticipant(AST.JLS3, true/*resolve binding*/) { |
| public void reconcile(ReconcileContext context) { |
| try { |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "public class X {\n" + |
| " public void bar() {\n" + |
| " toString()\n" + |
| " }\n" + |
| "}" |
| ); |
| context.resetAST(); |
| } catch (JavaModelException e) { |
| e.printStackTrace(); |
| } |
| } |
| }; |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "public class X {\n" + |
| " public void bar() {\n" + |
| " }\n" + |
| "}" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "1. ERROR in /Reconciler/src/p1/X.java (at line 4)\n" + |
| " toString()\n" + |
| " ^\n" + |
| "Syntax error, insert \";\" to complete BlockStatements\n" + |
| "----------\n" |
| ); |
| } |
| /** |
| * Ensures that the reconciler reconciles the new contents with the current |
| * contents, updating the structure of this reconciler's compilation |
| * unit, and fires the Java element deltas for the structural changes |
| * of a renaming a method; the original method deleted and the new method added structurally. |
| */ |
| public void testRenameMethod1() throws JavaModelException { |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " public void bar() {\n" + |
| " }\n" + |
| "}" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected delta", |
| "X[*]: {CHILDREN | FINE GRAINED}\n" + |
| " bar()[+]: {}\n" + |
| " foo()[-]: {}" |
| ); |
| } |
| /** |
| * Ensures that the reconciler reconciles the new contents with the current |
| * contents,updating the structure of this reconciler's compilation |
| * unit, and fires the Java element delta for the structural changes |
| * of the addition of a portion of a new method. |
| */ |
| public void testRenameWithSyntaxError() throws JavaModelException { |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "import p2.*;\n" + |
| "public class X {\n" + |
| " public void bar( {\n" + |
| " }\n" + |
| "}" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Unexpected delta", |
| "X[*]: {CHILDREN | FINE GRAINED}\n" + |
| " bar()[+]: {}\n" + |
| " foo()[-]: {}" |
| ); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "1. ERROR in /Reconciler/src/p1/X.java (at line 4)\n" + |
| " public void bar( {\n" + |
| " ^\n" + |
| "Syntax error, insert \")\" to complete MethodDeclaration\n" + |
| "----------\n" |
| ); |
| } |
| /* |
| * Ensure that warning are suppressed by an @SuppressWarnings annotation. |
| */ |
| //https://bugs.eclipse.org/bugs/show_bug.cgi?id=95056 |
| //TODO (kent) reenable once addressed |
| public void _testSuppressWarnings1() throws JavaModelException { |
| ICompilationUnit otherCopy = null; |
| try { |
| WorkingCopyOwner owner = new WorkingCopyOwner() {}; |
| otherCopy = getWorkingCopy( |
| "/Reconciler15/src/X.java", |
| "@Deprecated\n" + |
| "public class X {\n" + |
| " void foo(){}\n" + |
| "}\n", |
| owner, |
| false/*don't compute problems*/); |
| setUp15WorkingCopy("/Reconciler15/src/Y.java", owner); |
| setWorkingCopyContents( |
| "public class Y extends X {\n" + |
| " @SuppressWarnings(\"all\")\n" + |
| " void foo(){ super.foo(); }\n" + |
| " Zork z;\n" + |
| "}\n" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "1. WARNING in /Reconciler15/src/Y.java (at line 1)\n" + |
| " public class Y extends X {\n" + |
| " ^\n" + |
| "The constructor X() is deprecated\n" + |
| "----------\n" + |
| "2. WARNING in /Reconciler15/src/Y.java (at line 1)\n" + |
| " public class Y extends X {\n" + |
| " ^\n" + |
| "The type X is deprecated\n" + |
| "----------\n" + |
| "3. ERROR in /Reconciler15/src/Y.java (at line 4)\n" + |
| " Zork z;\n" + |
| " ^^^^\n" + |
| "Zork cannot be resolved to a type\n" + |
| "----------\n"); |
| } finally { |
| if (otherCopy != null) |
| otherCopy.discardWorkingCopy(); |
| } |
| } |
| /* |
| * Ensure that warning are suppressed by an @SuppressWarning annotation. |
| */ |
| public void testSuppressWarnings2() throws JavaModelException { |
| ICompilationUnit otherCopy = null; |
| try { |
| WorkingCopyOwner owner = new WorkingCopyOwner() {}; |
| otherCopy = getWorkingCopy( |
| "/Reconciler15/src/java/util/List.java", |
| "package java.util;\n" + |
| "public interface List<E> {\n" + |
| "}\n", |
| owner, |
| false/*don't compute problems*/); |
| setUp15WorkingCopy("/Reconciler15/src/X.java", owner); |
| setWorkingCopyContents( |
| "import java.util.List;\n" + |
| "\n" + |
| "public class X {\n" + |
| " void foo(List list) {\n" + |
| " List<String> ls1 = list;\n" + |
| " }\n" + |
| " @SuppressWarnings(\"unchecked\")\n" + |
| " void bar(List list) {\n" + |
| " List<String> ls2 = list;\n" + |
| " }\n" + |
| " Zork z;\n" + |
| "}\n" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "1. WARNING in /Reconciler15/src/X.java (at line 5)\n" + |
| " List<String> ls1 = list;\n" + |
| " ^^^^\n" + |
| "Type safety: The expression of type List needs unchecked conversion to conform to List<String>\n" + |
| "----------\n" + |
| "2. ERROR in /Reconciler15/src/X.java (at line 11)\n" + |
| " Zork z;\n" + |
| " ^^^^\n" + |
| "Zork cannot be resolved to a type\n" + |
| "----------\n" |
| ); |
| } finally { |
| if (otherCopy != null) |
| otherCopy.discardWorkingCopy(); |
| } |
| } |
| /* |
| * Ensure that warning are suppressed by an @SuppressWarning annotation. |
| */ |
| public void testSuppressWarnings3() throws JavaModelException { |
| ICompilationUnit otherCopy = null; |
| try { |
| WorkingCopyOwner owner = new WorkingCopyOwner() {}; |
| otherCopy = getWorkingCopy( |
| "/Reconciler15/src/java/util/HashMap.java", |
| "package java.util;\n" + |
| "public class HashMap implements Map {\n" + |
| "}\n", |
| owner, |
| false/*don't compute problems*/); |
| setUp15WorkingCopy("/Reconciler15/src/X.java", owner); |
| setWorkingCopyContents( |
| "import java.util.*;\n" + |
| "@SuppressWarnings(\"unchecked\")\n" + |
| "public class X {\n" + |
| " void foo() {\n" + |
| " Map<String, String>[] map = new HashMap[10];\n" + |
| " }\n" + |
| " Zork z;\n" + |
| "}\n" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "1. ERROR in /Reconciler15/src/X.java (at line 7)\n" + |
| " Zork z;\n" + |
| " ^^^^\n" + |
| "Zork cannot be resolved to a type\n" + |
| "----------\n" |
| ); |
| } finally { |
| if (otherCopy != null) |
| otherCopy.discardWorkingCopy(); |
| } |
| } |
| /* |
| * Ensure that warning are suppressed by an @SuppressWarnings annotation. |
| */ |
| public void testSuppressWarnings4() throws JavaModelException { |
| ICompilationUnit otherCopy = null; |
| try { |
| WorkingCopyOwner owner = new WorkingCopyOwner() {}; |
| otherCopy = getWorkingCopy( |
| "/Reconciler15/src/X.java", |
| "/** @deprecated */\n" + |
| "public class X {\n" + |
| " void foo(){}\n" + |
| "}\n", |
| owner, |
| false/*don't compute problems*/); |
| setUp15WorkingCopy("/Reconciler15/src/Y.java", owner); |
| setWorkingCopyContents( |
| "public class Y extends X {\n" + |
| " @SuppressWarnings(\"all\")\n" + |
| " void foo(){ super.foo(); }\n" + |
| " Zork z;\n" + |
| "}\n" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "1. WARNING in /Reconciler15/src/Y.java (at line 1)\n" + |
| " public class Y extends X {\n" + |
| " ^\n" + |
| "The constructor X() is deprecated\n" + |
| "----------\n" + |
| "2. WARNING in /Reconciler15/src/Y.java (at line 1)\n" + |
| " public class Y extends X {\n" + |
| " ^\n" + |
| "The type X is deprecated\n" + |
| "----------\n" + |
| "3. ERROR in /Reconciler15/src/Y.java (at line 4)\n" + |
| " Zork z;\n" + |
| " ^^^^\n" + |
| "Zork cannot be resolved to a type\n" + |
| "----------\n"); |
| } finally { |
| if (otherCopy != null) |
| otherCopy.discardWorkingCopy(); |
| } |
| } |
| /** |
| * Ensure that an unhandled exception is detected. |
| */ |
| public void testUnhandledException() throws JavaModelException { |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "public class X {\n" + |
| " public void foo() {\n" + |
| " throw new Exception();\n" + |
| " }\n" + |
| "}" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "1. ERROR in /Reconciler/src/p1/X.java (at line 4)\n" + |
| " throw new Exception();\n" + |
| " ^^^^^^^^^^^^^^^^^^^^^\n" + |
| "Unhandled exception type Exception\n" + |
| "----------\n" |
| ); |
| } |
| /** |
| * Check that forcing a make consistent action is leading the next reconcile to not notice changes. |
| */ |
| public void testMakeConsistentFoolingReconciler() throws JavaModelException { |
| setWorkingCopyContents(""); |
| this.workingCopy.makeConsistent(null); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, null, null); |
| assertDeltas( |
| "Should have got NO delta", |
| "" |
| ); |
| } |
| /** |
| * Test bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=60689 |
| * AST on reconcile: AST without Javadoc comments created |
| * @deprecated using deprecated code |
| */ |
| public void testBug60689() throws JavaModelException { |
| setWorkingCopyContents("public class X {\n" + |
| " /**\n" + |
| " * Returns the length of the string representing the number of \n" + |
| " * indents in the given string <code>line</code>. Returns \n" + |
| " * <code>-1<code> if the line isn't prefixed with an indent of\n" + |
| " * the given number of indents. \n" + |
| " */\n" + |
| " public static int computeIndentLength(String line, int numberOfIndents, int tabWidth) {\n" + |
| " return 0;\n" + |
| "}" |
| ); |
| org.eclipse.jdt.core.dom.CompilationUnit testCU = this.workingCopy.reconcile(AST.JLS2, true, null, null); |
| assertNotNull("We should have a comment!", testCU.getCommentList()); |
| assertEquals("We should have 1 comment!", 1, testCU.getCommentList().size()); |
| testCU = this.workingCopy.reconcile(AST.JLS2, true, null, null); |
| assertNotNull("We should have a comment!", testCU.getCommentList()); |
| assertEquals("We should have one comment!", 1, testCU.getCommentList().size()); |
| } |
| /* |
| * Ensures that a working copy in a 1.4 project that references a 1.5 project can be reconciled without error. |
| * (regression test for bug 98434 A non-1.5 project with 1.5 projects in the classpath does not show methods with generics) |
| */ |
| public void testTwoProjectsWithDifferentCompliances() throws CoreException { |
| this.workingCopy.discardWorkingCopy(); // don't use the one created in setUp() |
| try { |
| createJavaProject("P1", new String[] {""}, new String[] {"JCL15_LIB"}, "", "1.5"); |
| createFolder("/P1/p"); |
| createFile( |
| "/P1/p/X.java", |
| "package p;\n" + |
| "public class X {\n" + |
| " void foo(Class<String> c) {\n" + |
| " }\n" + |
| "}" |
| ); |
| |
| createJavaProject("P2", new String[] {""}, new String[] {"JCL_LIB"}, new String[] {"/P1"}, "", "1.4"); |
| createFolder("/P2/p"); |
| WorkingCopyOwner owner = new WorkingCopyOwner() {}; |
| this.workingCopy = getWorkingCopy("/P2/p/Y.java", "", owner, this.problemRequestor); |
| setWorkingCopyContents( |
| "package p;\n" + |
| "public class Y {\n" + |
| " void bar(Class c) {\n" + |
| " new X().foo(c);\n" + |
| " }\n" + |
| "}" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, true/*force pb detection*/, owner, null); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "----------\n" |
| ); |
| } finally { |
| deleteProjects(new String[] {"P1", "P2"}); |
| } |
| } |
| /* |
| * Ensures that a method that has a type parameter with bound can be overriden in another working copy. |
| * (regression test for bug 76780 [model] return type not recognized correctly on some generic methods) |
| */ |
| public void testTypeParameterWithBound() throws CoreException { |
| this.workingCopy.discardWorkingCopy(); // don't use the one created in setUp() |
| this.workingCopy = null; |
| WorkingCopyOwner owner = new WorkingCopyOwner() {}; |
| ICompilationUnit workingCopy1 = null; |
| try { |
| workingCopy1 = getWorkingCopy( |
| "/Reconciler15/src/test/I.java", |
| "package test;\n"+ |
| "public interface I {\n"+ |
| " <T extends I> void foo(T t);\n"+ |
| "}\n", |
| owner, |
| null /*no problem requestor*/ |
| ); |
| |
| this.problemRequestor = new ProblemRequestor(); |
| this.workingCopy = getWorkingCopy("Reconciler15/src/test/X.java", "", owner, this.problemRequestor); |
| setWorkingCopyContents( |
| "package test;\n"+ |
| "public class X implements I {\n"+ |
| " public <T extends I> void foo(T t) {\n"+ |
| " }\n"+ |
| "}\n" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, owner, null); |
| |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "----------\n" |
| ); |
| } finally { |
| if (workingCopy1 != null) { |
| workingCopy1.discardWorkingCopy(); |
| } |
| } |
| } |
| /* |
| * Ensures that a working copy with a type with a dollar name can be reconciled without errors. |
| * (regression test for bug 117121 Can't create class called A$B in eclipse) |
| */ |
| public void testTypeWithDollarName() throws CoreException { |
| this.workingCopy.discardWorkingCopy(); // don't use the one created in setUp() |
| this.workingCopy = null; |
| try { |
| String contents = |
| "package p1;\n" + |
| "public class Y$Z {\n" + |
| "}"; |
| createFile( |
| "/Reconciler/src/p1/Y$Z.java", |
| contents |
| ); |
| this.problemRequestor = new ProblemRequestor(); |
| this.workingCopy = getCompilationUnit("Reconciler/src/p1/Y$Z.java").getWorkingCopy(new WorkingCopyOwner() {}, this.problemRequestor, null); |
| |
| this.problemRequestor.initialize(contents.toCharArray()); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, true, null, null); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "----------\n" |
| ); |
| } finally { |
| deleteFile("/Reconciler/src/p1/Y$Z.java"); |
| } |
| } |
| /* |
| * Ensures that a varargs method can be referenced from another working copy. |
| */ |
| public void testVarargs() throws CoreException { |
| this.workingCopy.discardWorkingCopy(); // don't use the one created in setUp() |
| this.workingCopy = null; |
| WorkingCopyOwner owner = new WorkingCopyOwner() {}; |
| ICompilationUnit workingCopy1 = null; |
| try { |
| workingCopy1 = getWorkingCopy( |
| "/Reconciler15/src/test/X.java", |
| "package test;\n"+ |
| "public class X {\n"+ |
| " void bar(String ... args) {}\n"+ |
| "}\n", |
| owner, |
| null /*no problem requestor*/ |
| ); |
| |
| this.problemRequestor = new ProblemRequestor(); |
| this.workingCopy = getWorkingCopy("Reconciler15/src/test/Y.java", "", owner, this.problemRequestor); |
| setWorkingCopyContents( |
| "package test;\n"+ |
| "public class Y {\n"+ |
| " void foo(){\n"+ |
| " X someX = new X();\n"+ |
| " someX.bar(\"a\", \"b\");\n"+ |
| " }\n"+ |
| "}\n" |
| ); |
| this.workingCopy.reconcile(ICompilationUnit.NO_AST, false, owner, null); |
| |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "----------\n" |
| ); |
| } finally { |
| if (workingCopy1 != null) { |
| workingCopy1.discardWorkingCopy(); |
| } |
| } |
| } |
| |
| /** |
| * Bug 114338:[javadoc] Reconciler reports wrong javadoc warning (missing return type) |
| * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=114338" |
| * |
| */ |
| public void testBug114338() throws CoreException { |
| // Set initial CU content |
| setWorkingCopyContents( |
| "package p1;\n" + |
| "public class X {\n" + |
| " /**\n" + |
| " * @return a\n" + |
| " */\n" + |
| " boolean get() {\n" + |
| " return false;\n" + |
| " }\n" + |
| "}"); |
| this.workingCopy.reconcile(AST.JLS3, true, this.wcOwner, null); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "----------\n" |
| ); |
| |
| // Modify content |
| String contents = |
| "package p1;\n" + |
| "public class X {\n" + |
| " /**\n" + |
| " * @return boolean\n" + |
| " */\n" + |
| " boolean get() {\n" + |
| " return false;\n" + |
| " }\n" + |
| "}"; |
| setWorkingCopyContents(contents); |
| this.workingCopy.reconcile(AST.JLS3, true, this.wcOwner, null); |
| assertProblems( |
| "Unexpected problems", |
| "----------\n" + |
| "----------\n" |
| ); |
| } |
| |
| /** |
| * Bug 36032:[plan] JavaProject.findType() fails to find second type in source file |
| * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=36032" |
| * |
| */ |
| public void testBug36032a() throws CoreException, InterruptedException { |
| try { |
| // Resources creation |
| createJavaProject("P", new String[] {""}, new String[] {"JCL_LIB"}, "bin"); |
| String source = |
| "public class Test {\n" + |
| " public static void main(String[] args) {\n" + |
| " new SFoo().foo();\n" + |
| " }\n" + |
| "}\n"; |
| this.createFile( |
| "/P/Foo.java", |
| "class SFoo { void foo() {} }\n" |
| ); |
| this.createFile( |
| "/P/Test.java", |
| source |
| ); |
| |
| // Get compilation unit and reconcile it |
| char[] sourceChars = source.toCharArray(); |
| this.problemRequestor.initialize(sourceChars); |
| this.workingCopy = getCompilationUnit("/P/Test.java").getWorkingCopy(new WorkingCopyOwner() {}, problemRequestor, null); |
| this.workingCopy.getBuffer().setContents(source); |
| this.workingCopy.reconcile(AST.JLS3, true, null, null); |
| assertNoProblem(sourceChars); |
| |
| // Add new secondary type |
| this.createFile( |
| "/P/Bar.java", |
| "class SBar{ void bar() {} }\n" |
| ); |
| source = |
| "public class Test {\n" + |
| " public static void main(String[] args) {\n" + |
| " new SFoo().foo();\n" + |
| " new SBar().bar();\n" + |
| " }\n" + |
| "}\n"; |
| |
| // Reconcile with modified source |
| sourceChars = source.toCharArray(); |
| this.problemRequestor.initialize(sourceChars); |
| this.workingCopy.getBuffer().setContents(source); |
| this.workingCopy.reconcile(AST.JLS3, true, null, null); |
| assertNoProblem(sourceChars); |
| } finally { |
| deleteProject("P"); |
| } |
| } |
| public void testBug36032b() throws CoreException, InterruptedException { |
| try { |
| // Resources creation |
| createJavaProject("P", new String[] {""}, new String[] {"JCL_LIB"}, "bin"); |
| String source = |
| "public class Test {\n" + |
| " public static void main(String[] args) {\n" + |
| " new SFoo().foo();\n" + |
| " new SBar().bar();\n" + |
| " }\n" + |
| "}\n"; |
| createFile( |
| "/P/Foo.java", |
| "class SFoo { void foo() {} }\n" |
| ); |
| createFile( |
| "/P/Test.java", |
| source |
| ); |
| createFile( |
| "/P/Bar.java", |
| "class SBar{ void bar() {} }\n" |
| ); |
| |
| // Get compilation unit and reconcile it |
| char[] sourceChars = source.toCharArray(); |
| this.problemRequestor.initialize(sourceChars); |
| this.workingCopy = getCompilationUnit("/P/Test.java").getWorkingCopy(new WorkingCopyOwner() {}, this.problemRequestor, null); |
| this.workingCopy.getBuffer().setContents(source); |
| this.workingCopy.reconcile(AST.JLS3, true, null, null); |
| assertNoProblem(sourceChars); |
| |
| // Delete secondary type => should get a problem |
| waitUntilIndexesReady(); |
| deleteFile("/P/Bar.java"); |
| this.problemRequestor.initialize(source.toCharArray()); |
| this.workingCopy.reconcile(AST.JLS3, true, null, null); |
| assertEquals("Working copy should not find secondary type 'Bar'!", 1, this.problemRequestor.problemCount); |
| assertProblems("Working copy should have problem!", |
| "----------\n" + |
| "1. ERROR in /P/Test.java (at line 4)\n" + |
| " new SBar().bar();\n" + |
| " ^^^^\n" + |
| "SBar cannot be resolved to a type\n" + |
| "----------\n" |
| ); |
| |
| // Fix the problem |
| source = |
| "public class Test {\n" + |
| " public static void main(String[] args) {\n" + |
| " new SFoo().foo();\n" + |
| " }\n" + |
| "}\n"; |
| sourceChars = source.toCharArray(); |
| this.problemRequestor.initialize(sourceChars); |
| this.workingCopy.getBuffer().setContents(source); |
| this.workingCopy.reconcile(AST.JLS3, true, null, null); |
| assertNoProblem(sourceChars); |
| } finally { |
| deleteProject("P"); |
| } |
| } |
| // Secondary types used through multiple projects |
| public void testBug36032c() throws CoreException, InterruptedException { |
| try { |
| // Create first project |
| createJavaProject("P1", new String[] {""}, new String[] {"JCL_LIB"}, "bin"); |
| createFolder("/P1/test"); |
| createFile( |
| "/P1/test/Foo.java", |
| "package test;\n" + |
| "class Secondary{ void foo() {} }\n" |
| ); |
| createFile( |
| "/P1/test/Test1.java", |
| "package test;\n" + |
| "public class Test1 {\n" + |
| " public static void main(String[] args) {\n" + |
| " new Secondary().foo();\n" + |
| " }\n" + |
| "}\n" |
| ); |
| |
| // Create second project |
| createJavaProject("P2", new String[] {""}, new String[] {"JCL_LIB"}, new String[] { "/P1" }, "bin"); |
| String source = |
| "package test;\n" + |
| "public class Test2 {\n" + |
| " public static void main(String[] args) {\n" + |
| " new Secondary().foo();\n" + |
| " }\n" + |
| "}\n"; |
| createFolder("/P2/test"); |
| createFile( |
| "/P2/test/Test2.java", |
| source |
| ); |
| |
| // Get compilation unit and reconcile it => expect no error |
| char[] sourceChars = source.toCharArray(); |
| this.problemRequestor.initialize(sourceChars); |
| this.workingCopy = getCompilationUnit("/P2/test/Test2.java").getWorkingCopy(new WorkingCopyOwner() {}, this.problemRequestor, null); |
| this.workingCopy.getBuffer().setContents(source); |
| this.workingCopy.reconcile(AST.JLS3, true, null, null); |
| assertNoProblem(sourceChars); |
| } finally { |
| deleteProject("P1"); |
| deleteProject("P2"); |
| } |
| } |
| } |