Attachment 24131 Details for Bug 101777 – Regression tests

[patch] Regression tests

patch101777_org.eclipse.jdt.core.tests.model.txt (text/plain), 22.27 KB, created by Jerome Lanneluc

on 2005-06-29 10:12:01 EDT

(hide)

Description:

Filename:

MIME Type:

Creator: Jerome Lanneluc

Created: 2005-06-29 10:12:01 EDT

Size: 22.27 KB

patch

obsolete

>Index: src/org/eclipse/jdt/core/tests/model/JavaSearchMultipleProjectsTests.java
>===================================================================
>RCS file: /home/eclipse/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/JavaSearchMultipleProjectsTests.java,v
>retrieving revision 1.31
>diff -u -r1.31 JavaSearchMultipleProjectsTests.java
>--- src/org/eclipse/jdt/core/tests/model/JavaSearchMultipleProjectsTests.java	23 Jun 2005 16:15:17 -0000	1.31
>+++ src/org/eclipse/jdt/core/tests/model/JavaSearchMultipleProjectsTests.java	29 Jun 2005 14:03:55 -0000
>@@ -36,9 +36,10 @@
> // Use this static initializer to specify subset for tests
> // All specified tests which do not belong to the class are skipped...
> static {
>-//	TESTS_NAMES = new String[] { "testMethodOccurences" };
>+//	TESTS_NAMES = new String[] { "testJavaSearchScopeBug101426" };
> //	TESTS_NUMBERS = new int[] { 101426 };
> //	TESTS_RANGE = new int[] { 16, -1 };
>+//	TESTS_PREFIX = "testScopeEncloses";
> }
> protected void tearDown() throws Exception {
> 	// Cleanup caches
>@@ -872,6 +873,560 @@
> 		deleteProject("P2");
> 	}
> }
>+/*
>+ * Ensures that a Java project is enclosed in a scope on the project (proj=src)
>+ * (resourcePath case)
>+ */
>+public void testScopeEncloses01() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		assertTrue("scope on P should enclose \"/P\"", scope.encloses("/P"));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a Java project is enclosed in a scope on the project (proj=src)
>+ * (Java element case)
>+ */
>+public void testScopeEncloses02() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		assertTrue("scope on P should enclose P", scope.encloses(project));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a root is enclosed in a scope on the project (proj=src)
>+ * (resource path with traling slash case)
>+ */
>+public void testScopeEncloses03() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		assertTrue("scope on P should enclose \"/P/\"", scope.encloses("/P/"));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a root is enclosed in a scope on the project (proj=src)
>+ * (Java element case)
>+ */
>+public void testScopeEncloses04() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		IPackageFragmentRoot root = project.getPackageFragmentRoot(project.getProject());
>+		assertTrue("scope on P should enclose root P", scope.encloses(root));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a package is enclosed in a scope on the project (proj=src)
>+ * (resource path case)
>+ */
>+public void testScopeEncloses05() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		assertTrue("scope on P should enclose \"/P/x/y\"", scope.encloses("/P/x/y"));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a package is enclosed in a scope on the project (proj=src)
>+ * (resource path with trailing slash case)
>+ */
>+public void testScopeEncloses06() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		assertTrue("scope on P should enclose \"/P/x/y/\"", scope.encloses("/P/x/y/"));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a package is enclosed in a scope on the project (proj=src)
>+ * (Java element case)
>+ */
>+public void testScopeEncloses07() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		IPackageFragment pkg = getPackage("/P/x/y");
>+		assertTrue("scope on P should enclose package x.y", scope.encloses(pkg));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a default package is enclosed in a scope on the project (proj=src)
>+ * (Java element case)
>+ */
>+public void testScopeEncloses08() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		IPackageFragment pkg = getPackage("/P");
>+		assertTrue("scope on P should enclose default package", scope.encloses(pkg));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a compilation unit is enclosed in a scope on the project (proj=src)
>+ * (resource path case)
>+ */
>+public void testScopeEncloses09() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		assertTrue("scope on P should enclose \"/P/x/y/A.java\"", scope.encloses("/P/x/y/A.java"));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a compilation unit is enclosed in a scope on the project (proj=src)
>+ * (Java element case)
>+ */
>+public void testScopeEncloses10() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		ICompilationUnit cu = getCompilationUnit("/P/x/y/A.java");
>+		assertTrue("scope on P should enclose compilation unit A.java", scope.encloses(cu));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a compilation unit in the default package is enclosed in a scope on the project (proj=src)
>+ * (resource path case)
>+ */
>+public void testScopeEncloses11() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		assertTrue("scope on P should enclose \"/P/A.java\"", scope.encloses("/P/A.java"));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a compilation unit in the default package is enclosed in a scope on the project (proj=src)
>+ * (Java element case)
>+ */
>+public void testScopeEncloses12() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		ICompilationUnit cu = getCompilationUnit("/P/A.java");
>+		assertTrue("scope on P should enclose compilation unit A.java", scope.encloses(cu));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a source type is enclosed in a scope on the project (proj=src)
>+ * (Java element case)
>+ */
>+public void testScopeEncloses13() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		ICompilationUnit cu = getCompilationUnit("/P/x/y/A.java");
>+		IType type = cu.getType("A");
>+		assertTrue("scope on P should enclose type A", scope.encloses(type));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a Java project is not enclosed in a scope on the project (proj != src)
>+ * (resourcePath case)
>+ */
>+public void testScopeEncloses14() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		assertTrue("scope on P should not enclose \"/P\"", !scope.encloses("/P"));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a Java project is not enclosed in a scope on the project (proj != src)
>+ * (Java element case)
>+ */
>+public void testScopeEncloses15() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		assertTrue("scope on P should enclose P", !scope.encloses(project));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a root is enclosed in a scope on the project (proj != src)
>+ * (resource path case)
>+ */
>+public void testScopeEncloses16() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		assertTrue("scope on P should enclose \"/P/src\"", scope.encloses("/P/src"));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a root is enclosed in a scope on the project (proj != src)
>+ * (resource path with traling slash case)
>+ */
>+public void testScopeEncloses17() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		assertTrue("scope on P should enclose \"/P/src/\"", scope.encloses("/P/src/"));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a root is enclosed in a scope on the project (proj != src)
>+ * (Java element case)
>+ */
>+public void testScopeEncloses18() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		IPackageFragmentRoot root = project.getPackageFragmentRoot(project.getProject().getFolder("src"));
>+		assertTrue("scope on P should enclose root P/src", scope.encloses(root));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a package is enclosed in a scope on the project (proj != src)
>+ * (resource path case)
>+ */
>+public void testScopeEncloses19() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		assertTrue("scope on P should enclose \"/P/src/x/y\"", scope.encloses("/P/src/x/y"));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a package is enclosed in a scope on the project (proj != src)
>+ * (resource path with trailing slash case)
>+ */
>+public void testScopeEncloses20() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		assertTrue("scope on P should enclose \"/P/src/x/y/\"", scope.encloses("/P/src/x/y/"));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a package is enclosed in a scope on the project (proj != src)
>+ * (Java element case)
>+ */
>+public void testScopeEncloses21() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		IPackageFragment pkg = getPackage("/P/src/x/y");
>+		assertTrue("scope on P should enclose package x.y", scope.encloses(pkg));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a default package is enclosed in a scope on the project (proj != src)
>+ * (Java element case)
>+ */
>+public void testScopeEncloses22() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		IPackageFragment pkg = getPackage("/P/src");
>+		assertTrue("scope on P should enclose default package", scope.encloses(pkg));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a compilation unit is enclosed in a scope on the project (proj != src)
>+ * (resource path case)
>+ */
>+public void testScopeEncloses23() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		assertTrue("scope on P should enclose \"/P/src/x/y/A.java\"", scope.encloses("/P/src/x/y/A.java"));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a compilation unit is enclosed in a scope on the project (proj != src)
>+ * (Java element case)
>+ */
>+public void testScopeEncloses24() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		ICompilationUnit cu = getCompilationUnit("/P/src/x/y/A.java");
>+		assertTrue("scope on P should enclose compilation unit A.java", scope.encloses(cu));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a compilation unit in the default package is enclosed in a scope on the project (proj != src)
>+ * (resource path case)
>+ */
>+public void testScopeEncloses25() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		assertTrue("scope on P should enclose \"/P/src/A.java\"", scope.encloses("/P/src/A.java"));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a compilation unit in the default package is enclosed in a scope on the project (proj != src)
>+ * (Java element case)
>+ */
>+public void testScopeEncloses26() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		ICompilationUnit cu = getCompilationUnit("/P/src/A.java");
>+		assertTrue("scope on P should enclose compilation unit A.java", scope.encloses(cu));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a source type is enclosed in a scope on the project (proj != src)
>+ * (Java element case)
>+ */
>+public void testScopeEncloses27() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		ICompilationUnit cu = getCompilationUnit("/P/src/x/y/A.java");
>+		IType type = cu.getType("A");
>+		assertTrue("scope on P should enclose type A", scope.encloses(type));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a Java project is not enclosed in a scope on the project (proj != src/)
>+ * (resourcePath case)
>+ */
>+public void testScopeEncloses28() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src/"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		assertTrue("scope on P should not enclose \"/P\"", !scope.encloses("/P"));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a Java project is not enclosed in a scope on the project (proj != src/)
>+ * (Java element case)
>+ */
>+public void testScopeEncloses29() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src/"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		assertTrue("scope on P should enclose P", !scope.encloses(project));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a root is enclosed in a scope on the project (proj != src/)
>+ * (resource path case)
>+ */
>+public void testScopeEncloses30() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src/"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		assertTrue("scope on P should enclose \"/P/src\"", scope.encloses("/P/src"));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a root is enclosed in a scope on the project (proj != src/)
>+ * (resource path with traling slash case)
>+ */
>+public void testScopeEncloses31() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src/"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		assertTrue("scope on P should enclose \"/P/src/\"", scope.encloses("/P/src/"));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a root is enclosed in a scope on the project (proj != src/)
>+ * (Java element case)
>+ */
>+public void testScopeEncloses32() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src/"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		IPackageFragmentRoot root = project.getPackageFragmentRoot(project.getProject().getFolder("src"));
>+		assertTrue("scope on P should enclose root P/src", scope.encloses(root));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a package is enclosed in a scope on the project (proj != src/)
>+ * (resource path case)
>+ */
>+public void testScopeEncloses33() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src/"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		assertTrue("scope on P should enclose \"/P/src/x/y\"", scope.encloses("/P/src/x/y"));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a package is enclosed in a scope on the project (proj != src/)
>+ * (resource path with trailing slash case)
>+ */
>+public void testScopeEncloses34() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src/"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		assertTrue("scope on P should enclose \"/P/src/x/y/\"", scope.encloses("/P/src/x/y/"));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a package is enclosed in a scope on the project (proj != src/)
>+ * (Java element case)
>+ */
>+public void testScopeEncloses35() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src/"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		IPackageFragment pkg = getPackage("/P/src/x/y");
>+		assertTrue("scope on P should enclose package x.y", scope.encloses(pkg));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a default package is enclosed in a scope on the project (proj != src/)
>+ * (Java element case)
>+ */
>+public void testScopeEncloses36() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src/"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		IPackageFragment pkg = getPackage("/P/src");
>+		assertTrue("scope on P should enclose default package", scope.encloses(pkg));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a compilation unit is enclosed in a scope on the project (proj != src/)
>+ * (resource path case)
>+ */
>+public void testScopeEncloses37() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src/"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		assertTrue("scope on P should enclose \"/P/src/x/y/A.java\"", scope.encloses("/P/src/x/y/A.java"));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a compilation unit is enclosed in a scope on the project (proj != src/)
>+ * (Java element case)
>+ */
>+public void testScopeEncloses38() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src/"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		ICompilationUnit cu = getCompilationUnit("/P/src/x/y/A.java");
>+		assertTrue("scope on P should enclose compilation unit A.java", scope.encloses(cu));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a compilation unit in the default package is enclosed in a scope on the project (proj != src/)
>+ * (resource path case)
>+ */
>+public void testScopeEncloses39() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src/"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		assertTrue("scope on P should enclose \"/P/src/A.java\"", scope.encloses("/P/src/A.java"));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a compilation unit in the default package is enclosed in a scope on the project (proj != src/)
>+ * (Java element case)
>+ */
>+public void testScopeEncloses40() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src/"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		ICompilationUnit cu = getCompilationUnit("/P/src/A.java");
>+		assertTrue("scope on P should enclose compilation unit A.java", scope.encloses(cu));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
>+/*
>+ * Ensures that a source type is enclosed in a scope on the project (proj != src/)
>+ * (Java element case)
>+ */
>+public void testScopeEncloses41() throws CoreException {
>+	try {
>+		IJavaProject project = createJavaProject("P", new String[] {"src/"}, "bin");
>+		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {project});
>+		ICompilationUnit cu = getCompilationUnit("/P/src/x/y/A.java");
>+		IType type = cu.getType("A");
>+		assertTrue("scope on P should enclose type A", scope.encloses(type));
>+	} finally {
>+		deleteProject("P");
>+	}
>+}
> /**
>  * Type declaration in external jar file that is shared by 2 projects.
>  * (regression test for bug 27485 SearchEngine returns wrong java element when searching in an archive that is included by two distinct java projects.)

Actions: View | Diff

Attachments on bug 101777: 24130 | 24131