| /******************************************************************************* |
| * Copyright (c) 2000, 2009 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.wst.jsdt.core.tests.model; |
| |
| import java.io.File; |
| import java.io.IOException; |
| |
| import junit.framework.Test; |
| import junit.framework.TestSuite; |
| |
| import org.eclipse.core.resources.IContainer; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IFolder; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IWorkspace; |
| import org.eclipse.core.resources.IWorkspaceDescription; |
| import org.eclipse.core.resources.IWorkspaceRunnable; |
| import org.eclipse.core.resources.IncrementalProjectBuilder; |
| import org.eclipse.core.resources.ResourcesPlugin; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.runtime.preferences.IEclipsePreferences; |
| import org.eclipse.wst.jsdt.core.IAccessRule; |
| import org.eclipse.wst.jsdt.core.IFunction; |
| import org.eclipse.wst.jsdt.core.IIncludePathAttribute; |
| import org.eclipse.wst.jsdt.core.IIncludePathEntry; |
| import org.eclipse.wst.jsdt.core.IJavaScriptElement; |
| import org.eclipse.wst.jsdt.core.IJavaScriptModelStatusConstants; |
| import org.eclipse.wst.jsdt.core.IJavaScriptProject; |
| import org.eclipse.wst.jsdt.core.IJavaScriptUnit; |
| import org.eclipse.wst.jsdt.core.IPackageFragment; |
| import org.eclipse.wst.jsdt.core.IPackageFragmentRoot; |
| import org.eclipse.wst.jsdt.core.JavaScriptCore; |
| import org.eclipse.wst.jsdt.core.JavaScriptModelException; |
| import org.eclipse.wst.jsdt.internal.core.JavaModelManager; |
| import org.eclipse.wst.jsdt.internal.core.UserLibrary; |
| import org.eclipse.wst.jsdt.internal.core.UserLibraryManager; |
| |
| public class JavaProjectTests extends ModifyingResourceTests { |
| public JavaProjectTests(String name) { |
| super(name); |
| } |
| public static Test suite() { |
| TestSuite suite = (TestSuite) buildModelTestSuite(JavaProjectTests.class); |
| |
| // The following test must be at the end as it deletes a package and this would have side effects |
| // on other tests |
| if (suite.testCount() > 1) // if not running only 1 test |
| suite.addTest(new JavaProjectTests("lastlyTestDeletePackageWithAutobuild")); |
| |
| return suite; |
| } |
| public void setUpSuite() throws Exception { |
| super.setUpSuite(); |
| setUpJavaProject("JavaProjectTests"); |
| setUpJavaProject("JavaProjectSrcTests"); |
| setUpJavaProject("JavaProjectLibTests"); |
| } |
| public void tearDownSuite() throws Exception { |
| deleteProject("JavaProjectTests"); |
| deleteProject("JavaProjectSrcTests"); |
| deleteProject("JavaProjectLibTests"); |
| super.tearDownSuite(); |
| } |
| |
| |
| /** |
| * Test adding a non-java resource in a package fragment root that correspond to |
| * the project. |
| * (Regression test for PR #1G58NB8) |
| */ |
| public void testAddNonJavaResourcePackageFragmentRoot() throws JavaScriptModelException, CoreException { |
| // get resources of source package fragment root at project level |
| IPackageFragmentRoot root = getPackageFragmentRoot("JavaProjectTests", ""); |
| Object[] resources = root.getNonJavaScriptResources(); |
| assertResourceNamesEqual( |
| "unexpected non Java resources", |
| ".project\n" + |
| ".settings\n" + |
| "lib142530.jar\n" + |
| "lib148949.jar", |
| resources); |
| IFile resource = (IFile)resources[0]; |
| IPath newPath = root.getUnderlyingResource().getFullPath().append("TestNonJavaResource.abc"); |
| try { |
| // copy and rename resource |
| resource.copy( |
| newPath, |
| true, |
| null); |
| |
| // ensure the new resource is present |
| resources = root.getNonJavaScriptResources(); |
| assertResourcesEqual( |
| "incorrect non java resources", |
| "/JavaProjectTests/.project\n" + |
| "/JavaProjectTests/.settings\n" + |
| "/JavaProjectTests/TestNonJavaResource.abc\n" + |
| "/JavaProjectTests/lib142530.jar\n" + |
| "/JavaProjectTests/lib148949.jar", |
| resources); |
| } finally { |
| // clean up |
| deleteResource(resource.getWorkspace().getRoot().getFile(newPath)); |
| } |
| } |
| /* |
| * Ensures that adding a project prerequisite in the classpath updates the referenced projects |
| */ |
| public void testAddProjectPrerequisite() throws CoreException { |
| try { |
| createJavaProject("P1"); |
| createJavaProject("P2"); |
| waitForAutoBuild(); |
| editFile( |
| "/P2/.settings/.jsdtscope", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry kind=\"src\" path=\"/P1\"/>\n" + |
| "</classpath>" |
| ); |
| getProject("P2").build(IncrementalProjectBuilder.FULL_BUILD, null); |
| IProject[] referencedProjects = getProject("P2").getReferencedProjects(); |
| assertResourcesEqual( |
| "Unexpected project references", |
| "/P1", |
| referencedProjects); |
| } finally { |
| deleteProjects(new String[] {"P1", "P2"}); |
| } |
| } |
| /** |
| * Test that a compilation unit |
| * has a corresponding resource. |
| */ |
| public void testCompilationUnitCorrespondingResource() throws JavaScriptModelException { |
| IJavaScriptUnit element= getCompilationUnit("JavaProjectTests", "", "q", "A.js"); |
| IResource corr= element.getCorrespondingResource(); |
| IResource res= getWorkspace().getRoot().getProject("JavaProjectTests").getFolder("q").getFile("A.js"); |
| assertTrue("incorrect corresponding resource", corr.equals(res)); |
| assertEquals("Project is incorrect for the compilation unit", "JavaProjectTests", corr.getProject().getName()); |
| } |
| /** |
| * Tests the fix for "1FWNMKD: ITPJCORE:ALL - Package Fragment Removal not reported correctly" |
| */ |
| public void lastlyTestDeletePackageWithAutobuild() throws CoreException { |
| // close all project except JavaProjectTests so as to avoid side effects while autobuilding |
| IProject[] projects = getWorkspaceRoot().getProjects(); |
| for (int i = 0; i < projects.length; i++) { |
| IProject project = projects[i]; |
| if (project.getName().equals("JavaProjectTests")) continue; |
| project.close(null); |
| } |
| |
| // turn autobuilding on |
| IWorkspace workspace = getWorkspace(); |
| boolean autoBuild = workspace.isAutoBuilding(); |
| IWorkspaceDescription description = workspace.getDescription(); |
| description.setAutoBuilding(true); |
| workspace.setDescription(description); |
| |
| startDeltas(); |
| IPackageFragment frag = getPackageFragment("JavaProjectTests", "", "x.y"); |
| IFolder folder = (IFolder) frag.getUnderlyingResource(); |
| try { |
| deleteResource(folder); |
| assertDeltas( |
| "Unexpected delta", |
| "JavaProjectTests[*]: {CHILDREN}\n" + |
| " <project root>[*]: {CHILDREN}\n" + |
| " x.y[-]: {}" |
| ); |
| } finally { |
| stopDeltas(); |
| |
| // turn autobuild off |
| description.setAutoBuilding(autoBuild); |
| workspace.setDescription(description); |
| |
| // reopen projects |
| projects = getWorkspaceRoot().getProjects(); |
| for (int i = 0; i < projects.length; i++) { |
| IProject project = projects[i]; |
| if (project.getName().equals("JavaProjectTests")) continue; |
| project.open(null); |
| } |
| } |
| } |
| /** |
| * Test that an (external) jar |
| * has no corresponding resource. |
| */ |
| public void testExternalArchiveCorrespondingResource() throws JavaScriptModelException { |
| IJavaScriptProject project= getJavaProject("JavaProjectTests"); |
| IPackageFragmentRoot element= project.getPackageFragmentRoot(getSystemJsPathString()); |
| IResource corr= element.getCorrespondingResource(); |
| assertTrue("incorrect corresponding resource", corr == null); |
| } |
| /* |
| * Ensures that a file with an extra Java-like extension is listed in the children of a package. |
| */ |
| public void testExtraJavaLikeExtension1() throws CoreException { |
| try { |
| createJavaProject("P"); |
| createFolder("/P/pack"); |
| createFile("/P/pack/X.js", "function X() {}"); |
| createFile("/P/pack/Y.bar", "function Y() {}"); |
| IPackageFragment pkg = getPackage("/P/pack"); |
| assertSortedElementsEqual( |
| "Unexpected children of package pack", |
| "X.js [in pack [in <project root> [in P]]]", |
| pkg.getChildren()); |
| } finally { |
| deleteProject("P"); |
| } |
| } |
| /* |
| * Ensures that a file with an extra Java-like extension is not listed in the non-Java resources of a package. |
| */ |
| public void testExtraJavaLikeExtension2() throws CoreException { |
| try { |
| createJavaProject("P"); |
| createFolder("/P/pack"); |
| createFile("/P/pack/X.txt", ""); |
| createFile("/P/pack/Y.bar", "function Y() {}"); |
| IPackageFragment pkg = getPackage("/P/pack"); |
| assertResourceNamesEqual( |
| "Unexpected non-Java resources of package pack", |
| "X.txt\n" + |
| "Y.bar", |
| pkg.getNonJavaScriptResources()); |
| } finally { |
| deleteProject("P"); |
| } |
| } |
| /** |
| * Test that a compilation unit can be found |
| */ |
| public void testFindElementCompilationUnit() throws JavaScriptModelException { |
| IJavaScriptProject project= getJavaProject("JavaProjectTests"); |
| IJavaScriptElement element= project.findElement(new Path("x/y/Main.js")); |
| assertTrue("CU not found" , element != null && element.getElementType() == IJavaScriptElement.JAVASCRIPT_UNIT |
| && element.getElementName().equals("Main.js")); |
| } |
| /** |
| * Test that a compilation unit can be found in a default package |
| */ |
| public void testFindElementCompilationUnitDefaultPackage() throws JavaScriptModelException { |
| IJavaScriptProject project= getJavaProject("JavaProjectTests"); |
| IJavaScriptElement element= project.findElement(new Path("B.js")); |
| assertTrue("CU not found" , element != null && element.getElementType() == IJavaScriptElement.JAVASCRIPT_UNIT |
| && element.getElementName().equals("B.js")); |
| } |
| /** |
| * Test that an invlaid path throws an exception |
| */ |
| public void testFindElementInvalidPath() throws JavaScriptModelException { |
| IJavaScriptProject project= getJavaProject("JavaProjectTests"); |
| boolean failed= false; |
| try { |
| project.findElement(null); |
| } catch (JavaScriptModelException e) { |
| failed= true; |
| assertTrue("wrong status code" , e.getStatus().getCode() == IJavaScriptModelStatusConstants.INVALID_PATH); |
| } |
| assertTrue("Shold have failed", failed); |
| |
| failed = false; |
| try { |
| project.findElement(new Path("/something/absolute")); |
| } catch (JavaScriptModelException e) { |
| failed= true; |
| assertTrue("wrong status code" , e.getStatus().getCode() == IJavaScriptModelStatusConstants.INVALID_PATH); |
| } |
| assertTrue("Shold have failed", failed); |
| |
| IJavaScriptElement element= project.findElement(new Path("does/not/exist/HelloWorld.js")); |
| assertTrue("should get no element", element == null); |
| } |
| /** |
| * Test that a package can be found |
| */ |
| public void testFindElementPackage() throws JavaScriptModelException { |
| IJavaScriptProject project= getJavaProject("JavaProjectTests"); |
| IJavaScriptElement element= project.findElement(new Path("x/y")); |
| assertTrue("package not found" , element != null && element.getElementType() == IJavaScriptElement.PACKAGE_FRAGMENT |
| && element.getElementName().equals("x.y")); |
| } |
| /** |
| * Test that a class can be found even if the project prereq a simple project |
| * (regression test for bug 28434 Open Type broken when workspace has build path problems) |
| */ |
| public void testFindElementPrereqSimpleProject() throws CoreException { |
| try { |
| this.createProject("R"); |
| IJavaScriptProject project = this.createJavaProject("J", new String[] {"src"}, new String[] {}, new String[] {"/R"}); |
| this.createFile( |
| "J/src/X.js", |
| "public class X {\n" + |
| "}" |
| ); |
| assertTrue("X.java not found", project.findElement(new Path("X.js")) != null); |
| } finally { |
| this.deleteProject("R"); |
| this.deleteProject("J"); |
| } |
| } |
| /** |
| * Test that a package fragment root can be found from a classpath entry. |
| */ |
| public void testFindPackageFragmentRootFromClasspathEntry() { |
| IJavaScriptProject project = getJavaProject("JavaProjectTests"); |
| |
| // existing classpath entry |
| IIncludePathEntry entry = JavaScriptCore.newLibraryEntry(new Path("/JavaProjectTests/lib.jar"), null, null); |
| IPackageFragmentRoot[] roots = project.findPackageFragmentRoots(entry); |
| assertEquals("Unexpected number of roots for existing entry", 1, roots.length); |
| assertEquals("Unexpected root", "/JavaProjectTests/lib.jar", roots[0].getPath().toString()); |
| |
| // non-existing classpath entry |
| entry = JavaScriptCore.newSourceEntry(new Path("/JavaProjectTests/nonExisting")); |
| roots = project.findPackageFragmentRoots(entry); |
| assertEquals("Unexpected number of roots for non existing entry", 0, roots.length); |
| |
| } |
| /** |
| * Test that a folder with a dot name does not relate to a package fragment |
| */ |
| public void testFolderWithDotName() throws JavaScriptModelException, CoreException { |
| IPackageFragmentRoot root= getPackageFragmentRoot("JavaProjectTests", ""); |
| IContainer folder= (IContainer)root.getCorrespondingResource(); |
| try { |
| startDeltas(); |
| folder.getFolder(new Path("org.eclipse")).create(false, true, null); |
| assertTrue("should be one Java Delta", this.deltaListener.deltas.length == 1); |
| |
| stopDeltas(); |
| IJavaScriptElement[] children = root.getChildren(); |
| IPackageFragment bogus = root.getPackageFragment("org.eclipse"); |
| for (int i = 0; i < children.length; i++) { |
| assertTrue("org.eclipse should not be present as child", !children[i].equals(bogus)); |
| } |
| assertTrue("org.eclipse should not exist", !bogus.exists()); |
| } finally { |
| deleteResource(folder.getFolder(new Path("org.eclipse"))); |
| } |
| } |
| /* |
| * Ensures that getting the classpath on a closed project throws a JavaScriptModelException |
| * (regression test for bug 25358 Creating a new Java class - Browse for parent) |
| */ |
| public void testGetClasspathOnClosedProject() throws CoreException { |
| IProject project = getProject("JavaProjectTests"); |
| try { |
| project.close(null); |
| boolean gotException = false; |
| IJavaScriptProject javaProject = JavaScriptCore.create(project); |
| try { |
| javaProject.getRawIncludepath(); |
| } catch (JavaScriptModelException e) { |
| if (e.isDoesNotExist()) { |
| gotException = true; |
| } |
| } |
| assertTrue("Should get a not present exception for getRawClasspath()", gotException); |
| gotException = false; |
| try { |
| javaProject.getResolvedIncludepath(true); |
| } catch (JavaScriptModelException e) { |
| if (e.isDoesNotExist()) { |
| gotException = true; |
| } |
| } |
| assertTrue("Should get a not present exception for getResolvedClasspath(true)", gotException); |
| } finally { |
| project.open(null); |
| } |
| } |
| /* |
| * Ensures that the non-java resources for a project do not contain the project output location. |
| */ |
| public void testGetNonJavaResources1() throws CoreException { |
| try { |
| IJavaScriptProject project = this.createJavaProject("P", new String[] {"src"}); |
| assertResourcesEqual( |
| "Unexpected non-java resources for project", |
| "/P/.project\n" + |
| "/P/.settings", |
| project.getNonJavaScriptResources()); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| /* |
| * Ensures that the non-java resources for a project do not contain a custom output location. |
| * (regression test for 27494 Source folder output folder shown in Package explorer) |
| */ |
| public void testGetNonJavaResources2() throws CoreException { |
| try { |
| IJavaScriptProject project = this.createJavaProject("P", new String[] {"src"}, "bin1", new String[] {"bin2"}); |
| assertResourcesEqual( |
| "Unexpected non-java resources for project", |
| "/P/.project\n" + |
| "/P/.settings", |
| project.getNonJavaScriptResources()); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| /* |
| * Ensures that the non-java resources for a project do not contain a folder that should be a package fragment. |
| */ |
| public void testGetNonJavaResources3() throws CoreException { |
| try { |
| IJavaScriptProject project = this.createJavaProject("P", new String[] {""}); |
| this.createFolder("/P/p1"); |
| assertResourcesEqual( |
| "Unexpected non-java resources for project", |
| "/P/.project\n" + |
| "/P/.settings", |
| project.getNonJavaScriptResources()); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| /* |
| * Ensures that the non-java resources for a project contain a folder that have an invalid name for a package fragment. |
| * (regression test for bug 31757 Folder with invalid pkg name should be non-Java resource) |
| */ |
| public void testGetNonJavaResources4() throws CoreException { |
| try { |
| IJavaScriptProject project = this.createJavaProject("P"); |
| this.createFolder("/P/x.y"); |
| assertResourcesEqual( |
| "Unexpected non-java resources for project", |
| "/P/.project\n" + |
| "/P/.settings\n" + |
| "/P/x.y", |
| project.getNonJavaScriptResources()); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| /* |
| * Ensures that getRequiredProjectNames() returns the project names in the classpath order |
| * (regression test for bug 25605 [API] someJavaProject.getRequiredProjectNames(); API should specify that the array is returned in ClassPath order) |
| */ |
| public void testGetRequiredProjectNames() throws CoreException { |
| try { |
| IJavaScriptProject project = this.createJavaProject( |
| "P", |
| new String[] {}, |
| new String[] {}, |
| new String[] {"/JavaProjectTests", "/P1", "/P0", "/P2", "/JavaProjectSrcTests"}); |
| String[] requiredProjectNames = project.getRequiredProjectNames(); |
| StringBuffer buffer = new StringBuffer(); |
| for (int i = 0, length = requiredProjectNames.length; i < length; i++) { |
| buffer.append(requiredProjectNames[i]); |
| if (i != length-1) { |
| buffer.append(", "); |
| } |
| } |
| assertEquals( |
| "Unexpected required project names", |
| "JavaProjectTests, P1, P0, P2, JavaProjectSrcTests", |
| buffer.toString()); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| /** |
| * Test that an (internal) jar |
| * has a corresponding resource. |
| */ |
| public void testInternalArchiveCorrespondingResource() throws JavaScriptModelException { |
| IPackageFragmentRoot element= getPackageFragmentRoot("JavaProjectTests", "lib.jar"); |
| IResource corr= element.getCorrespondingResource(); |
| IResource res= getWorkspace().getRoot().getProject("JavaProjectTests").getFile("lib.jar"); |
| assertTrue("incorrect corresponding resource", corr.equals(res)); |
| } |
| /** |
| * Test IJavaPackageFragment.isDefaultPackage(). |
| */ |
| public void testIsDefaultPackage() throws JavaScriptModelException { |
| IPackageFragment def = getPackageFragment("JavaProjectTests", "", ""); |
| assertTrue("should be default package", def.isDefaultPackage()); |
| IPackageFragment y = |
| getPackageFragment("JavaProjectTests", "", "x.y"); |
| assertTrue("x.y should not be default pakackage", !y.isDefaultPackage()); |
| |
| IPackageFragment def2 = getPackageFragment("JavaProjectTests", "lib.jar", ""); |
| assertTrue("lib.jar should have default package", def2.isDefaultPackage()); |
| IPackageFragment p = |
| getPackageFragment("JavaProjectTests", "lib.jar", "p"); |
| assertTrue("p should not be default package", !p.isDefaultPackage()); |
| } |
| /** |
| * Test that a package fragment (non-external, non-jar, non-default) |
| * has a corresponding resource. |
| */ |
| public void testPackageFragmentCorrespondingResource() throws JavaScriptModelException { |
| IPackageFragment element= getPackageFragment("JavaProjectTests", "", "x.y"); |
| IResource corr= element.getCorrespondingResource(); |
| IResource res= getWorkspace().getRoot().getProject("JavaProjectTests").getFolder("x").getFolder("y"); |
| assertTrue("incorrect corresponding resource", corr.equals(res)); |
| } |
| /** |
| * Test that a package fragment (non-external, non-jar, non-default) |
| * has a corresponding resource. |
| */ |
| public void testPackageFragmentHasSubpackages() throws JavaScriptModelException { |
| IPackageFragment def= getPackageFragment("JavaProjectTests", "", ""); |
| IPackageFragment x= getPackageFragment("JavaProjectTests", "", "x"); |
| IPackageFragment y= getPackageFragment("JavaProjectTests", "", "x.y"); |
| assertTrue("default should have subpackages", def.hasSubpackages()); |
| assertTrue("x should have subpackages", x.hasSubpackages()); |
| assertTrue("x.y should NOT have subpackages", !y.hasSubpackages()); |
| |
| IPackageFragment java = getPackageFragment("JavaProjectTests", getSystemJsPathString(), "java"); |
| IPackageFragment lang= getPackageFragment("JavaProjectTests", getSystemJsPathString(), "java.lang"); |
| |
| assertTrue("java should have subpackages", java.hasSubpackages()); |
| assertTrue("java.lang should NOT have subpackages", !lang.hasSubpackages()); |
| } |
| /* |
| * Ensures that the structure is known for a package fragment on the classpath. |
| */ |
| public void testPackageFragmentIsStructureKnown1() throws CoreException { |
| IPackageFragment pkg = getPackageFragment("JavaProjectTests", "", "x"); |
| assertTrue("Structure of package 'x' should be known", pkg.isStructureKnown()); |
| } |
| /* |
| * Ensures that asking if the structure is known for a package fragment outside the classpath throws a JavaScriptModelException. |
| * (regression test for bug 138577 Package content disapear in package explorer) |
| */ |
| public void testPackageFragmentIsStructureKnown2() throws CoreException { |
| try { |
| createJavaProject("P"); |
| createFolder("/P/pack"); |
| IPackageFragment pkg = getPackage("/P/pack"); |
| editFile( |
| "/P/.classpath", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry excluding=\"pack/\" kind=\"src\" path=\"\"/>\n" + |
| " <classpathentry kind=\"output\" path=\"\"/>\n" + |
| "</classpath>" |
| ); |
| JavaScriptModelException exception = null; |
| try { |
| pkg.isStructureKnown(); |
| } catch (JavaScriptModelException e) { |
| exception = e; |
| } |
| assertExceptionEquals( |
| "Unexpected exception", |
| "pack [in <project root> [in P]] does not exist", |
| exception); |
| } finally { |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Ensure that the non-Java resources of a source package are correct. |
| */ |
| public void testPackageFragmentNonJavaResources1() throws JavaScriptModelException { |
| // regular source package with resources |
| IPackageFragment pkg = getPackageFragment("JavaProjectTests", "", "x"); |
| Object[] resources = pkg.getNonJavaScriptResources(); |
| assertResourcesEqual( |
| "Unexpected resources", |
| "/JavaProjectTests/x/readme.txt\n" + |
| "/JavaProjectTests/x/readme2.txt", |
| resources); |
| } |
| |
| /* |
| * Ensure that the non-Java resources of a source package without resources are correct. |
| */ |
| public void testPackageFragmentNonJavaResources2() throws JavaScriptModelException { |
| IPackageFragment pkg = getPackageFragment("JavaProjectTests", "", "x.y"); |
| Object[] resources = pkg.getNonJavaScriptResources(); |
| assertResourcesEqual( |
| "Unexpected resources", |
| "", |
| resources); |
| } |
| |
| /* |
| * Ensure that the non-Java resources of the default package are correct. |
| */ |
| public void testPackageFragmentNonJavaResources3() throws JavaScriptModelException { |
| IPackageFragment pkg = getPackageFragment("JavaProjectTests", "", ""); |
| Object[] resources = pkg.getNonJavaScriptResources(); |
| assertResourcesEqual( |
| "Unexpected resources", |
| "", |
| resources); |
| } |
| |
| /* |
| * Ensure that the non-Java resources of a zip package without resources are correct. |
| */ |
| public void testPackageFragmentNonJavaResources4() throws JavaScriptModelException { |
| IPackageFragment pkg = getPackageFragment("JavaProjectTests", "lib.jar", "p"); |
| Object[] resources = pkg.getNonJavaScriptResources(); |
| assertResourcesEqual( |
| "Unexpected resources", |
| "", |
| resources); |
| } |
| |
| // TODO: zip default package with potentialy resources |
| |
| /* |
| * Ensure that the non-Java resources of a zip default package without resources are correct. |
| */ |
| public void testPackageFragmentNonJavaResources5() throws JavaScriptModelException { |
| IPackageFragment pkg = getPackageFragment("JavaProjectTests", "lib.jar", ""); |
| Object[] resources = pkg.getNonJavaScriptResources(); |
| assertResourcesEqual( |
| "Unexpected resources", |
| "", |
| resources); |
| } |
| |
| /* |
| * Ensure that the non-Java resources of a zip package with resources are correct. |
| * (regression test for bug 142530 [hierarchical packages] '.' in folder names confuses package explorer) |
| */ |
| public void testPackageFragmentNonJavaResources6() throws JavaScriptModelException { |
| // regular zip package without resources |
| IPackageFragment pkg = getPackageFragment("JavaProjectTests", "lib142530.jar", "p"); |
| Object[] resources = pkg.getNonJavaScriptResources(); |
| assertResourcesEqual( |
| "Unexpected resources", |
| "x.y/Test.txt", |
| resources); |
| } |
| |
| /* |
| * Ensure that the non-Java resources of a zip package with resources are correct. |
| * (regression test for bug 148949 JarEntryFile now returning 'null') |
| */ |
| public void testPackageFragmentNonJavaResources7() throws JavaScriptModelException { |
| // regular zip package without resources |
| IPackageFragment pkg = getPackageFragment("JavaProjectTests", "lib148949.jar", "p"); |
| Object[] resources = pkg.getNonJavaScriptResources(); |
| assertResourceNamesEqual( |
| "Unexpected resources", |
| "test.txt", |
| resources); |
| } |
| |
| /* |
| * Ensures that the package-info.class file doesn't appear as a child of a package if proj=src |
| * (regression test for bug 99654 [5.0] JavaModel returns both IClassFile and IJavaScriptUnit for package-info.java) |
| */ |
| public void testPackageFragmentPackageInfoClass() throws CoreException { |
| try { |
| createJavaProject("P"); |
| createFolder("/P/p1"); |
| IPackageFragment pkg = getPackage("/P/p1"); |
| pkg.open(null); |
| createFile("/P/p1/package-info.class", ""); |
| assertResourceNamesEqual( |
| "Unexpected resources of /P/p1", |
| "", |
| pkg.getNonJavaScriptResources()); |
| } finally { |
| deleteProject("P"); |
| } |
| } |
| /** |
| * Tests that after a package "foo" has been renamed into "bar", it is possible to recreate |
| * a "foo" package. |
| * @see "1FWX0HY: ITPCORE:WIN98 - Problem after renaming a Java package" |
| */ |
| public void testPackageFragmentRenameAndCreate() throws JavaScriptModelException, CoreException { |
| IPackageFragment y = getPackageFragment("JavaProjectTests", "", "x.y"); |
| IFolder yFolder = (IFolder) y.getUnderlyingResource(); |
| IPath yPath = yFolder.getFullPath(); |
| IPath fooPath = yPath.removeLastSegments(1).append("foo"); |
| |
| yFolder.move(fooPath, true, null); |
| try { |
| yFolder.create(true, true, null); |
| } catch (Throwable e) { |
| e.printStackTrace(); |
| assertTrue("should be able to recreate the y folder", false); |
| } |
| // restore the original state |
| deleteResource(yFolder); |
| IPackageFragment foo = getPackageFragment("JavaProjectTests", "", "x.foo"); |
| IFolder fooFolder = (IFolder) foo.getUnderlyingResource(); |
| fooFolder.move(yPath, true, null); |
| } |
| /** |
| * Test that a package fragment root (non-external, non-jar, non-default root) |
| * has a corresponding resource. |
| */ |
| public void testPackageFragmentRootCorrespondingResource() throws JavaScriptModelException { |
| IPackageFragmentRoot element= getPackageFragmentRoot("JavaProjectTests", ""); |
| IResource corr= element.getCorrespondingResource(); |
| IResource res= getWorkspace().getRoot().getProject("JavaProjectTests"); |
| assertTrue("incorrect corresponding resource", corr.equals(res)); |
| assertEquals("Project incorrect for folder resource", "JavaProjectTests", corr.getProject().getName()); |
| } |
| /** |
| * Test getting the non-java resources from a package fragment root. |
| */ |
| public void testPackageFragmentRootNonJavaResources() throws JavaScriptModelException { |
| // source package fragment root with resources |
| IPackageFragmentRoot root = getPackageFragmentRoot("JavaProjectTests", ""); |
| Object[] resources = root.getNonJavaScriptResources(); |
| assertResourceNamesEqual( |
| "unexpected non java resoures (test case 1)", |
| ".project\n" + |
| ".settings\n" + |
| "lib142530.jar\n" + |
| "lib148949.jar", |
| resources); |
| |
| // source package fragment root without resources |
| root = getPackageFragmentRoot("JavaProjectSrcTests", "src"); |
| resources = root.getNonJavaScriptResources(); |
| assertResourceNamesEqual( |
| "unexpected non java resoures (test case 2)", |
| "", |
| resources); |
| |
| // zip package fragment root with resources |
| // TO DO |
| |
| // zip package fragment root without resources |
| root = getPackageFragmentRoot("JavaProjectTests", "lib.jar"); |
| resources = root.getNonJavaScriptResources(); |
| assertResourceNamesEqual( |
| "unexpected non java resoures (test case 4)", |
| "MANIFEST.MF", |
| resources); |
| } |
| /** |
| * Test raw entry inference performance for package fragment root |
| */ |
| public void testPackageFragmentRootRawEntry() throws CoreException, IOException { |
| File libDir = null; |
| try { |
| String libPath = getExternalPath() + "lib"; |
| JavaScriptCore.setIncludepathVariable("MyVar", new Path(libPath), null); |
| IJavaScriptProject proj = this.createJavaProject("P", new String[] {}); |
| libDir = new File(libPath); |
| libDir.mkdirs(); |
| final int length = 200; |
| IIncludePathEntry[] classpath = new IIncludePathEntry[length]; |
| for (int i = 0; i < length; i++){ |
| File libJar = new File(libDir, "lib"+i+".jar"); |
| libJar.createNewFile(); |
| classpath[i] = JavaScriptCore.newVariableEntry(new Path("/MyVar/lib"+i+".jar"), null, null); |
| } |
| proj.setRawIncludepath(classpath, null); |
| |
| IPackageFragmentRoot[] roots = proj.getPackageFragmentRoots(); |
| assertEquals("wrong number of entries:", length, roots.length); |
| //long start = System.currentTimeMillis(); |
| for (int i = 0; i < roots.length; i++){ |
| IIncludePathEntry rawEntry = roots[i].getRawIncludepathEntry(); |
| assertEquals("unexpected root raw entry:", classpath[i], rawEntry); |
| } |
| //System.out.println((System.currentTimeMillis() - start)+ "ms for "+roots.length+" roots"); |
| } finally { |
| if (libDir != null) { |
| org.eclipse.wst.jsdt.core.tests.util.Util.delete(libDir); |
| } |
| this.deleteProject("P"); |
| JavaScriptCore.removeIncludepathVariable("MyVar", null); |
| } |
| } |
| /** |
| * Test raw entry inference performance for package fragment root in case |
| * original classpath had duplicate entries pointing to it: first raw entry should be found |
| */ |
| public void testPackageFragmentRootRawEntryWhenDuplicate() throws CoreException, IOException { |
| File libDir = null; |
| try { |
| String externalPath = getExternalPath(); |
| String libPath = externalPath + "lib"; |
| JavaScriptCore.setIncludepathVariable("MyVar", new Path(externalPath), null); |
| IJavaScriptProject proj = this.createJavaProject("P", new String[] {}); |
| libDir = new File(libPath); |
| libDir.mkdirs(); |
| IIncludePathEntry[] classpath = new IIncludePathEntry[2]; |
| File libJar = new File(libDir, "lib.jar"); |
| libJar.createNewFile(); |
| classpath[0] = JavaScriptCore.newLibraryEntry(new Path(libPath).append("lib.jar"), null, null); |
| classpath[1] = JavaScriptCore.newVariableEntry(new Path("/MyVar").append("lib.jar"), null, null); |
| proj.setRawIncludepath(classpath, null); |
| JavaScriptCore.setIncludepathVariable("MyVar", new Path(libPath), null); // change CP var value to cause collision |
| |
| IPackageFragmentRoot[] roots = proj.getPackageFragmentRoots(); |
| assertEquals("wrong number of entries:", 1, roots.length); |
| IIncludePathEntry rawEntry = roots[0].getRawIncludepathEntry(); |
| assertEquals("unexpected root raw entry:", classpath[0], rawEntry); // ensure first entry is associated to the root |
| } finally { |
| if (libDir != null) { |
| org.eclipse.wst.jsdt.core.tests.util.Util.delete(libDir); |
| } |
| this.deleteProject("P"); |
| JavaScriptCore.removeIncludepathVariable("MyVar", null); |
| } |
| } |
| /* |
| * Ensures that opening a project update the project references |
| * (regression test for bug 73253 [model] Project references not set on project open) |
| */ |
| public void testProjectOpen() throws CoreException { |
| try { |
| createJavaProject("P1"); |
| createJavaProject("P2", new String[0], new String[0], new String[] {"/P1"}); |
| IProject p2 = getProject("P2"); |
| p2.close(null); |
| p2.open(null); |
| IProject[] references = p2.getDescription().getDynamicReferences(); |
| assertResourcesEqual( |
| "Unexpected referenced projects", |
| "/P1", |
| references); |
| } finally { |
| deleteProjects(new String[] {"P1", "P2"}); |
| } |
| } |
| /** |
| * Tests that closing and opening a project triggers the correct deltas. |
| */ |
| public void testProjectClose() throws JavaScriptModelException, CoreException { |
| IJavaScriptProject jproject= getJavaProject("JavaProjectTests"); |
| IPackageFragmentRoot[] originalRoots = jproject.getPackageFragmentRoots(); |
| IProject project= jproject.getProject(); |
| |
| try { |
| startDeltas(); |
| project.close(null); |
| assertDeltas( |
| "Unexpected delta 1", |
| "JavaProjectTests[*]: {CLOSED}\n" + |
| "ResourceDelta(/JavaProjectTests)" |
| ); |
| } finally { |
| try { |
| clearDeltas(); |
| |
| project.open(null); |
| assertDeltas( |
| "Unexpected delta 2", |
| "JavaProjectTests[*]: {OPENED}\n" + |
| "ResourceDelta(/JavaProjectTests)" |
| ); |
| |
| IPackageFragmentRoot[] openRoots = jproject.getPackageFragmentRoots(); |
| assertTrue("should have same number of roots", openRoots.length == originalRoots.length); |
| for (int i = 0; i < openRoots.length; i++) { |
| assertTrue("root not the same", openRoots[i].equals(originalRoots[i])); |
| } |
| } finally { |
| stopDeltas(); |
| } |
| } |
| } |
| /** |
| * Test that a project has a corresponding resource. |
| */ |
| public void testProjectCorrespondingResource() throws JavaScriptModelException { |
| IJavaScriptProject project= getJavaProject("JavaProjectTests"); |
| IResource corr= project.getCorrespondingResource(); |
| IResource res= getWorkspace().getRoot().getProject("JavaProjectTests"); |
| assertTrue("incorrect corresponding resource", corr.equals(res)); |
| } |
| /** |
| * Test that the correct children exist in a project |
| */ |
| public void testProjectGetChildren() throws JavaScriptModelException { |
| IJavaScriptProject project = getJavaProject("JavaProjectTests"); |
| IJavaScriptElement[] roots= project.getChildren(); |
| assertElementsEqual( |
| "Unexpected package fragment roots", |
| "<project root> [in JavaProjectTests]\n" + |
| getSystemJsPathString() + "\n" + |
| "lib.jar [in JavaProjectTests]\n" + |
| "lib142530.jar [in JavaProjectTests]\n" + |
| "lib148949.jar [in JavaProjectTests]", |
| roots); |
| } |
| /** |
| * Test that the correct package fragments exist in the project. |
| */ |
| public void testProjectGetPackageFragments() throws JavaScriptModelException { |
| IJavaScriptProject project= getJavaProject("JavaProjectTests"); |
| IPackageFragment[] fragments= project.getPackageFragments(); |
| assertSortedElementsEqual( |
| "unexpected package fragments", |
| "<default> [in "+ getSystemJsPathString() + "]\n" + |
| "q [in <project root> [in JavaProjectTests]]\n" + |
| "x [in <project root> [in JavaProjectTests]]\n" + |
| "x/y [in <project root> [in JavaProjectTests]]", |
| fragments); |
| } |
| /* |
| * Ensures that importing a project correctly update the project references |
| * (regression test for bug 121569 [Import/Export] Importing projects in workspace, the default build order is alphabetical instead of by dependency) |
| */ |
| public void testProjectImport() throws CoreException { |
| try { |
| createJavaProject("P1"); |
| IWorkspaceRunnable runnable = new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| createJavaProject("P2"); |
| editFile( |
| "/P2/.settings/.jsdtscope", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry kind=\"src\" path=\"/P1\"/>\n" + |
| " <classpathentry kind=\"output\" path=\"\"/>\n" + |
| "</classpath>" |
| ); |
| } |
| }; |
| getWorkspace().run(runnable, null); |
| waitForAutoBuild(); |
| IProject[] referencedProjects = getProject("P2").getReferencedProjects(); |
| assertResourcesEqual( |
| "Unexpected project references", |
| "/P1", |
| referencedProjects); |
| } finally { |
| deleteProjects(new String[] {"P1", "P2"}); |
| } |
| } |
| /** |
| * Test that the correct package fragments exist in the project. |
| */ |
| public void testRootGetPackageFragments() throws JavaScriptModelException { |
| IPackageFragmentRoot root= getPackageFragmentRoot("JavaProjectTests", ""); |
| IJavaScriptElement[] fragments= root.getChildren(); |
| assertElementsEqual( |
| "unexpected package fragments in source folder", |
| "<default> [in <project root> [in JavaProjectTests]]\n" + |
| "q [in <project root> [in JavaProjectTests]]\n" + |
| "x [in <project root> [in JavaProjectTests]]\n" + |
| "x/y [in <project root> [in JavaProjectTests]]", |
| fragments); |
| |
| root= getPackageFragmentRoot("JavaProjectTests", "lib.jar"); |
| fragments= root.getChildren(); |
| assertSortedElementsEqual( |
| "unexpected package fragments in library", |
| "<default> [in lib.jar [in JavaProjectTests]]\n" + |
| "p [in lib.jar [in JavaProjectTests]]", |
| fragments); |
| } |
| /** |
| * Test that the correct package fragments exist in the project. |
| * (regression test for bug 65693 Package Explorer shows .class files instead of .java) |
| */ |
| public void testRootGetPackageFragments3() throws CoreException { |
| try { |
| IJavaScriptProject p1 = createJavaProject("P1"); |
| createFile( |
| "/P1/X.js", |
| "function X() {\n" + |
| "}" |
| ); |
| getProject("P1").build(IncrementalProjectBuilder.FULL_BUILD, null); |
| IJavaScriptProject p2 = createJavaProject("P2"); |
| editFile( |
| "/P2/.settings/.jsdtscope", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry kind=\"src\" path=\"\"/>\n" + |
| " <classpathentry kind=\"lib\" path=\"/P1\"/>\n" + |
| "</classpath>" |
| ); |
| IPackageFragment pkg = p1.getPackageFragmentRoot(p1.getProject()).getPackageFragment(""); |
| assertElementsEqual( |
| "Unexpected packages for P1", |
| "X.js [in <default> [in <project root> [in P1]]]", |
| pkg.getChildren()); |
| pkg = p2.getPackageFragmentRoot(p1.getProject()).getPackageFragment(""); |
| assertElementsEqual( |
| "Unexpected packages for P2", |
| "X.js [in <default> [in /P1 [in P2]]]", |
| pkg.getChildren()); |
| } finally { |
| deleteProject("P1"); |
| deleteProject("P2"); |
| } |
| } |
| /** |
| * Ensure a source folder can have a name ending with ".jar" |
| */ |
| public void testSourceFolderWithJarName() throws CoreException { |
| try { |
| this.createJavaProject("P", new String[] {"src.jar"}); |
| IFile file = createFile("/P/src.jar/X.js", "class X {}"); |
| IJavaScriptUnit unit = (IJavaScriptUnit)JavaScriptCore.create(file); |
| unit.getAllTypes(); // force to open |
| } catch (CoreException e) { |
| assertTrue("unable to open unit in 'src.jar' source folder", false); |
| } finally { |
| this.deleteProject("P"); |
| } |
| }/** |
| * Test that a method |
| * has no corresponding resource. |
| */ |
| public void testSourceMethodCorrespondingResource() throws JavaScriptModelException { |
| IJavaScriptUnit element= getCompilationUnit("JavaProjectTests", "", "q", "A.js"); |
| IFunction[] methods = element.getFunctions(); |
| assertTrue("missing methods", methods.length > 0); |
| IResource corr= methods[0].getCorrespondingResource(); |
| assertTrue("incorrect corresponding resource", corr == null); |
| } |
| |
| /** |
| * Test User Library preference. External jar file referenced in library entry does not exist. |
| * It does not need to as we only test the preference value... |
| * |
| * @test bug 88719: UserLibrary.serialize /createFromString need support for access restriction / attributes |
| * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=88719" |
| */ |
| public void testUserLibrary() throws JavaScriptModelException { |
| |
| IIncludePathEntry[] userEntries = new IIncludePathEntry[2]; |
| |
| // Set first classpath entry |
| IPath path = new Path("/tmp/test.jar"); |
| IAccessRule[] pathRules = new IAccessRule[3]; |
| pathRules[0] = JavaScriptCore.newAccessRule(new Path("**/forbidden/**"), IAccessRule.K_NON_ACCESSIBLE); |
| pathRules[1] = JavaScriptCore.newAccessRule(new Path("**/discouraged/**"), IAccessRule.K_DISCOURAGED); |
| pathRules[2] = JavaScriptCore.newAccessRule(new Path("**/accessible/**"), IAccessRule.K_ACCESSIBLE); |
| IIncludePathAttribute[] extraAttributes = new IIncludePathAttribute[2]; |
| extraAttributes[0] = JavaScriptCore.newIncludepathAttribute("javadoc_location", "http://www.sample-url.org/doc/"); |
| extraAttributes[1] = JavaScriptCore.newIncludepathAttribute("org.eclipse.wst.jsdt.launching.CLASSPATH_ATTR_LIBRARY_PATH_ENTRY", "/tmp"); |
| userEntries[0] = JavaScriptCore.newLibraryEntry(path, null, null, pathRules, extraAttributes, false); |
| |
| // Set second classpath entry |
| path = new Path("/tmp/test.jar"); |
| pathRules = new IAccessRule[3]; |
| pathRules[0] = JavaScriptCore.newAccessRule(new Path("/org/eclipse/forbidden/**"), IAccessRule.K_NON_ACCESSIBLE); |
| pathRules[1] = JavaScriptCore.newAccessRule(new Path("/org/eclipse/discouraged/**"), IAccessRule.K_DISCOURAGED); |
| pathRules[2] = JavaScriptCore.newAccessRule(new Path("/org/eclipse/accessible/**"), IAccessRule.K_ACCESSIBLE); |
| extraAttributes = new IIncludePathAttribute[2]; |
| extraAttributes[0] = JavaScriptCore.newIncludepathAttribute("javadoc_location", "http://www.sample-url.org/doc/"); |
| extraAttributes[1] = JavaScriptCore.newIncludepathAttribute("org.eclipse.wst.jsdt.launching.CLASSPATH_ATTR_LIBRARY_PATH_ENTRY", "/tmp"); |
| userEntries[1] = JavaScriptCore.newLibraryEntry(path, null, null, pathRules, extraAttributes, false); |
| |
| // Create user library |
| UserLibrary library = new UserLibrary(userEntries, false); |
| UserLibraryManager.setUserLibrary("TEST", library, null); |
| |
| // Verify it has been written in preferences |
| IEclipsePreferences instancePreferences = JavaModelManager.getJavaModelManager().getInstancePreferences(); |
| String containerKey = UserLibraryManager.CP_USERLIBRARY_PREFERENCES_PREFIX+"TEST"; |
| String libraryPreference = instancePreferences.get(containerKey, null); |
| assertNotNull("Should get a preference for TEST user library", libraryPreference); |
| |
| assertSourceEquals( |
| "Invalid library contents", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<userlibrary systemlibrary=\"false\" version=\"1\">\n" + |
| " <archive path=\"/tmp/test.jar\">\n" + |
| " <attributes>\n" + |
| " <attribute name=\"javadoc_location\" value=\"http://www.sample-url.org/doc/\"/>\n" + |
| " <attribute name=\"org.eclipse.wst.jsdt.launching.CLASSPATH_ATTR_LIBRARY_PATH_ENTRY\" value=\"/tmp\"/>\n" + |
| " </attributes>\n" + |
| " <accessrules>\n" + |
| " <accessrule kind=\"nonaccessible\" pattern=\"**/forbidden/**\"/>\n" + |
| " <accessrule kind=\"discouraged\" pattern=\"**/discouraged/**\"/>\n" + |
| " <accessrule kind=\"accessible\" pattern=\"**/accessible/**\"/>\n" + |
| " </accessrules>\n" + |
| " </archive>\n" + |
| " <archive path=\"/tmp/test.jar\">\n" + |
| " <attributes>\n" + |
| " <attribute name=\"javadoc_location\" value=\"http://www.sample-url.org/doc/\"/>\n" + |
| " <attribute name=\"org.eclipse.wst.jsdt.launching.CLASSPATH_ATTR_LIBRARY_PATH_ENTRY\" value=\"/tmp\"/>\n" + |
| " </attributes>\n" + |
| " <accessrules>\n" + |
| " <accessrule kind=\"nonaccessible\" pattern=\"/org/eclipse/forbidden/**\"/>\n" + |
| " <accessrule kind=\"discouraged\" pattern=\"/org/eclipse/discouraged/**\"/>\n" + |
| " <accessrule kind=\"accessible\" pattern=\"/org/eclipse/accessible/**\"/>\n" + |
| " </accessrules>\n" + |
| " </archive>\n" + |
| "</userlibrary>\n", |
| libraryPreference); |
| } |
| |
| /** |
| * @bug 148859: [model][delta] Package Explorer only shows default package after import |
| * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=148859" |
| */ |
| public void testBug148859() throws CoreException { |
| try { |
| ResourcesPlugin.getWorkspace().run( |
| new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| IJavaScriptProject project = createJavaProject("P"); |
| project.findType("X"); |
| createFolder("/P/pack"); |
| } |
| }, |
| null); |
| IPackageFragmentRoot root = getPackageFragmentRoot("P", ""); |
| assertElementsEqual( |
| "Unexpected children size in 'P' default source folder", |
| "<default> [in <project root> [in P]]\n" + |
| "pack [in <project root> [in P]]", |
| root.getChildren()); |
| } finally { |
| deleteProject("P"); |
| } |
| } |
| } |