| /******************************************************************************* |
| * 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.ByteArrayInputStream; |
| import java.io.File; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| import java.util.Hashtable; |
| import java.util.Map; |
| |
| import junit.framework.Test; |
| |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IFolder; |
| import org.eclipse.core.resources.IMarker; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IProjectDescription; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IResourceChangeEvent; |
| import org.eclipse.core.resources.IResourceChangeListener; |
| import org.eclipse.core.resources.IWorkspace; |
| 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.wst.jsdt.core.IAccessRule; |
| import org.eclipse.wst.jsdt.core.IIncludePathAttribute; |
| import org.eclipse.wst.jsdt.core.IIncludePathEntry; |
| import org.eclipse.wst.jsdt.core.IJavaScriptElementDelta; |
| import org.eclipse.wst.jsdt.core.IJavaScriptModelMarker; |
| import org.eclipse.wst.jsdt.core.IJavaScriptModelStatus; |
| import org.eclipse.wst.jsdt.core.IJavaScriptProject; |
| import org.eclipse.wst.jsdt.core.IJavaScriptUnit; |
| import org.eclipse.wst.jsdt.core.IJsGlobalScopeContainer; |
| import org.eclipse.wst.jsdt.core.IPackageFragment; |
| import org.eclipse.wst.jsdt.core.IPackageFragmentRoot; |
| import org.eclipse.wst.jsdt.core.JavaScriptConventions; |
| import org.eclipse.wst.jsdt.core.JavaScriptCore; |
| import org.eclipse.wst.jsdt.core.JavaScriptModelException; |
| import org.eclipse.wst.jsdt.core.tests.util.Util; |
| import org.eclipse.wst.jsdt.internal.core.ClasspathEntry; |
| import org.eclipse.wst.jsdt.internal.core.JavaModelManager; |
| import org.eclipse.wst.jsdt.internal.core.JavaProject; |
| |
| public class ClasspathTests extends ModifyingResourceTests { |
| |
| public class TestContainer implements IJsGlobalScopeContainer { |
| IPath path; |
| IIncludePathEntry[] entries; |
| TestContainer(IPath path, IIncludePathEntry[] entries){ |
| this.path = path; |
| this.entries = entries; |
| } |
| public IPath getPath() { return this.path; } |
| /** |
| * @deprecated Use {@link #getIncludepathEntries()} instead |
| */ |
| public IIncludePathEntry[] getClasspathEntries() { |
| return getIncludepathEntries(); |
| } |
| public IIncludePathEntry[] getIncludepathEntries() { return this.entries; } |
| public String getDescription() { return this.path.toString(); } |
| public int getKind() { return 0; } |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.jsdt.core.IJsGlobalScopeContainer#resolvedLibraryImport(java.lang.String) |
| */ |
| public String[] resolvedLibraryImport(String a) { |
| return new String[] {a}; |
| } |
| } |
| |
| public ClasspathTests(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 { |
| // Names of tests to run: can be "testBugXXXX" or "BugXXXX") |
| // TESTS_PREFIX = "testClasspathDuplicateExtraAttribute"; |
| // TESTS_NAMES = new String[] {"testClasspathValidation42"}; |
| // TESTS_NUMBERS = new int[] { 23, 28, 38 }; |
| // TESTS_RANGE = new int[] { 21, 38 }; |
| } |
| public static Test suite() { |
| return buildModelTestSuite(ClasspathTests.class); |
| } |
| public void setUpSuite() throws Exception { |
| super.setUpSuite(); |
| |
| setupExternalJCL("jclMin"); |
| } |
| protected void assertCycleMarkers(IJavaScriptProject project, IJavaScriptProject[] p, int[] expectedCycleParticipants) throws CoreException { |
| waitForAutoBuild(); |
| StringBuffer expected = new StringBuffer("{"); |
| int expectedCount = 0; |
| StringBuffer computed = new StringBuffer("{"); |
| int computedCount = 0; |
| for (int j = 0; j < p.length; j++){ |
| int markerCount = this.numberOfCycleMarkers(p[j]); |
| if (markerCount > 0){ |
| if (computedCount++ > 0) computed.append(", "); |
| computed.append(p[j].getElementName()); |
| //computed.append(" (" + markerCount + ")"); |
| } |
| markerCount = expectedCycleParticipants[j]; |
| if (markerCount > 0){ |
| if (expectedCount++ > 0) expected.append(", "); |
| expected.append(p[j].getElementName()); |
| //expected.append(" (" + markerCount + ")"); |
| } |
| } |
| expected.append("}"); |
| computed.append("}"); |
| assertEquals("Invalid cycle detection after setting classpath for: "+project.getElementName(), expected.toString(), computed.toString()); |
| } |
| private void assertEncodeDecodeEntry(String projectName, String expectedEncoded, IIncludePathEntry entry) { |
| IJavaScriptProject project = getJavaProject(projectName); |
| String encoded = project.encodeIncludepathEntry(entry); |
| assertSourceEquals( |
| "Unexpected encoded entry", |
| expectedEncoded, |
| encoded); |
| IIncludePathEntry decoded = project.decodeIncludepathEntry(encoded); |
| assertEquals( |
| "Unexpected decoded entry", |
| entry, |
| decoded); |
| } |
| protected File createFile(File parent, String name, String content) throws IOException { |
| File file = new File(parent, name); |
| FileOutputStream out = new FileOutputStream(file); |
| out.write(content.getBytes()); |
| out.close(); |
| /* |
| * Need to change the time stamp to realize that the file has been modified |
| */ |
| file.setLastModified(System.currentTimeMillis() + 2000); |
| return file; |
| } |
| protected File createFolder(File parent, String name) { |
| File file = new File(parent, name); |
| file.mkdirs(); |
| return file; |
| } |
| protected int numberOfCycleMarkers(IJavaScriptProject javaProject) throws CoreException { |
| IMarker[] markers = javaProject.getProject().findMarkers(IJavaScriptModelMarker.BUILDPATH_PROBLEM_MARKER, false, IResource.DEPTH_ZERO); |
| int result = 0; |
| for (int i = 0, length = markers.length; i < length; i++) { |
| IMarker marker = markers[i]; |
| String cycleAttr = (String)marker.getAttribute(IJavaScriptModelMarker.CYCLE_DETECTED); |
| if (cycleAttr != null && cycleAttr.equals("true")){ //$NON-NLS-1$ |
| result++; |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * Add an entry to the classpath for a non-existent root. Then create |
| * the root and ensure that it comes alive. |
| */ |
| public void testAddRoot1() throws CoreException { |
| IJavaScriptProject project = this.createJavaProject("P", new String[] {"src"}); |
| IIncludePathEntry[] originalCP= project.getRawIncludepath(); |
| |
| try { |
| IIncludePathEntry newEntry= JavaScriptCore.newSourceEntry(project.getProject().getFullPath().append("extra")); |
| |
| IIncludePathEntry[] newCP= new IIncludePathEntry[originalCP.length + 1]; |
| System.arraycopy(originalCP, 0 , newCP, 0, originalCP.length); |
| newCP[originalCP.length]= newEntry; |
| |
| project.setRawIncludepath(newCP, null); |
| |
| // now create the actual resource for the root and populate it |
| project.getProject().getFolder("extra").create(false, true, null); |
| |
| IPackageFragmentRoot newRoot= getPackageFragmentRoot("P", "extra"); |
| assertTrue("New root should now be visible", newRoot != null); |
| } finally { |
| // cleanup |
| this.deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Adds an entry to the classpath for a non-existent root. Then creates |
| * the root and ensures that the marker is removed. |
| * (regression test for bug 161581 Adding a missing folder doesn't remove classpath marker) |
| */ |
| public void testAddRoot2() throws CoreException { |
| try { |
| IJavaScriptProject project = createJavaProject("P", new String[] {}); |
| project.setRawIncludepath(createClasspath("P", new String[] {"/P/src", ""}), null); |
| waitForAutoBuild(); |
| |
| // now create the actual resource for the root |
| project.getProject().getFolder("src").create(false, true, null); |
| assertMarkers("Unexpected markers", "", project); |
| } finally { |
| // cleanup |
| this.deleteProject("P"); |
| } |
| } |
| |
| /** |
| * Ensures that the reordering external resources in the classpath |
| * generates the correct deltas. |
| */ |
| public void testClasspathChangeExternalResources() throws CoreException { |
| try { |
| IJavaScriptProject proj = this.createJavaProject("P", new String[] {"src"}); |
| |
| IIncludePathEntry[] newEntries = new IIncludePathEntry[2]; |
| newEntries[0] = JavaScriptCore.newLibraryEntry(getSystemJsPath(), null, null, false); |
| newEntries[1] = JavaScriptCore.newLibraryEntry(getExternalJCLSourcePath(), null, null, false); |
| setClasspath(proj, newEntries); |
| startDeltas(); |
| IIncludePathEntry[] swappedEntries = new IIncludePathEntry[2]; |
| swappedEntries[0] = newEntries[1]; |
| swappedEntries[1] = newEntries[0]; |
| setClasspath(proj, swappedEntries); |
| assertDeltas( |
| "Unexpected delta", |
| "P[*]: {CHILDREN | CONTENT | CLASSPATH CHANGED}\n" + |
| " "+ getSystemJsPathString() +"[*]: {REORDERED}\n" + |
| " "+ getExternalJCLSourcePathString() +"[*]: {REORDERED}\n" + |
| " ResourceDelta(/P/.settings)[*]" |
| ); |
| } finally { |
| stopDeltas(); |
| this.deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Test classpath corruption (23977) |
| */ |
| public void testClasspathCorruption() throws CoreException { |
| try { |
| JavaProject p1 = (JavaProject)this.createJavaProject("P1", new String[]{""}, new String[]{}, new String[]{}); |
| this.createJavaProject("P2", new String[]{""}, new String[]{}, new String[]{}); |
| this.createFile("P2/foo.txt", "not a project"); |
| String newCPContent = |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?> \n" |
| +"<classpath> \n" |
| +" <classpathentry kind=\"src\" path=\"\"/> \n" |
| +" <classpathentry kind=\"src\" path=\"/P2/foo.txt\"/> \n" // corruption here: target isn't a project |
| +"</classpath> \n"; |
| |
| IFile fileRsc = p1.getProject().getFile(JavaProject.SHARED_PROPERTIES_DIRECTORY + "/" + JavaProject.CLASSPATH_FILENAME); |
| fileRsc.setContents(new ByteArrayInputStream(newCPContent.getBytes()), true, false, null); |
| |
| p1.close(); |
| JavaModelManager.PerProjectInfo perProjectInfo = JavaModelManager.getJavaModelManager().getPerProjectInfo(p1.getProject(), true/*create if missing*/); |
| perProjectInfo.setClasspath(null, null, null, null, null, null, null); |
| |
| // shouldn't fail |
| p1.getExpandedClasspath(); |
| |
| // if could reach that far, then all is fine |
| |
| } catch(ClassCastException e){ |
| assertTrue("internal ClassCastException on corrupted classpath file", false); |
| } finally { |
| // cleanup |
| this.deleteProject("P1"); |
| this.deleteProject("P2"); |
| } |
| } |
| |
| /* |
| * Test classpath read for non-javascript project or javascript project not opened yet (40658) |
| */ |
| public void testClasspathFileRead() throws CoreException { |
| try { |
| final IProject proj = this.createProject("P1"); |
| String newCPContent = |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?> \n" |
| +"<classpath> \n" |
| +" <classpathentry kind=\"src\" path=\"src\"/> \n" |
| +"</classpath> \n"; |
| |
| this.createFolder("/P1/.settings/"); |
| this.createFile("/P1/.settings/"+JavaProject.CLASSPATH_FILENAME, newCPContent); |
| final IJavaScriptProject jproj = JavaScriptCore.create(proj); |
| IWorkspace workspace = ResourcesPlugin.getWorkspace(); |
| workspace.run(new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) { |
| |
| IIncludePathEntry[] entries = jproj.readRawIncludepath(); // force to read classpath |
| IIncludePathEntry entry = entries[0]; |
| assertEquals("first classpath entry should have been read", "/P1/src", entry.getPath().toString()); |
| } |
| }, null); |
| } finally { |
| // cleanup |
| this.deleteProject("P1"); |
| } |
| } |
| |
| /* |
| * Test classpath forced reload (20931) and new way to read classpath file (40658) |
| */ |
| public void testClasspathForceReload() throws CoreException { |
| try { |
| final JavaProject p1 = (JavaProject)this.createJavaProject("P1", new String[]{""}, new String[]{}, new String[]{}); |
| IWorkspace workspace = ResourcesPlugin.getWorkspace(); |
| workspace.run(new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| |
| p1.getRawIncludepath(); // force to read classpath |
| createFolder("P1/src"); |
| String newCPContent = |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?> \n" |
| +"<classpath> \n" |
| +" <classpathentry kind=\"src\" path=\"src\"/> \n" |
| +"</classpath> \n"; |
| |
| IFile fileRsc = p1.getProject().getFile(JavaProject.SHARED_PROPERTIES_DIRECTORY + "/" + JavaProject.CLASSPATH_FILENAME); |
| fileRsc.setContents(new ByteArrayInputStream(newCPContent.getBytes()), true, false, null); |
| |
| p1.close(); |
| IIncludePathEntry[] entries = p1.readRawIncludepath(); // force to read classpath |
| assertEquals("source location should not have been refreshed", "/P1", entries[0].getPath().toString()); |
| } |
| }, null); |
| } finally { |
| // cleanup |
| this.deleteProject("P1"); |
| } |
| } |
| |
| /** |
| * Ensures that the setting the classpath with a library entry |
| * changes the kind of the root from K_SOURCE to K_BINARY. |
| */ |
| public void testClasspathCreateLibraryEntry() throws CoreException { |
| try { |
| IJavaScriptProject proj = this.createJavaProject("P", new String[] {"src"}); |
| this.createFile("P/src/X.js", "function X() {}"); |
| |
| IFolder rootFolder = proj.getProject().getFolder(new Path("src")); |
| IPackageFragmentRoot root = proj.getPackageFragmentRoot(rootFolder); |
| |
| assertEquals( |
| "Unexpected root kind 1", |
| IPackageFragmentRoot.K_SOURCE, |
| root.getKind()); |
| IPackageFragment pkg = root.getPackageFragment(""); |
| assertEquals( |
| "Unexpected numbers of compilation units", |
| 1, |
| pkg.getJavaScriptUnits().length); |
| |
| this.setClasspath( |
| proj, |
| new IIncludePathEntry[] { |
| JavaScriptCore.newLibraryEntry(rootFolder.getFullPath(), null, null, false) |
| }); |
| assertEquals( |
| "Unexpected root kind 2", |
| IPackageFragmentRoot.K_BINARY, |
| root.getKind()); |
| assertEquals( |
| "Unexpected numbers of compilation units", |
| 0, |
| pkg.getJavaScriptUnits().length); |
| |
| //ensure that the new kind has been persisted in the classpath file |
| proj.close(); |
| assertEquals( |
| "Unexpected root kind 3", |
| IPackageFragmentRoot.K_BINARY, |
| root.getKind()); |
| |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| |
| /** |
| * Tests the cross project classpath setting |
| */ |
| public void testClasspathCrossProject() throws CoreException { |
| IJavaScriptProject project = this.createJavaProject("P1", new String[] {""}); |
| this.createJavaProject("P2", new String[] {}); |
| try { |
| startDeltas(); |
| IPackageFragmentRoot oldRoot= getPackageFragmentRoot("P1", ""); |
| IIncludePathEntry projectEntry= JavaScriptCore.newProjectEntry(new Path("/P2"), false); |
| IIncludePathEntry[] newClasspath= new IIncludePathEntry[]{projectEntry}; |
| project.setRawIncludepath(newClasspath, null); |
| project.getAllPackageFragmentRoots(); |
| IJavaScriptElementDelta removedDelta= getDeltaFor(oldRoot, true); |
| assertDeltas( |
| "Unexpected delta", |
| "<project root>[*]: {REMOVED FROM CLASSPATH}", |
| removedDelta); |
| } finally { |
| stopDeltas(); |
| this.deleteProjects(new String[] {"P1", "P2"}); |
| } |
| } |
| /** |
| * Delete a root and ensure the classpath is not updated (i.e. entry isn't removed). |
| */ |
| public void testClasspathDeleteNestedRoot() throws CoreException { |
| IJavaScriptProject project = this.createJavaProject("P", new String[] {"nested/src"}, new String[] {}); |
| IPackageFragmentRoot root= getPackageFragmentRoot("P", "nested/src"); |
| IIncludePathEntry[] originalCP= project.getRawIncludepath(); |
| |
| // delete the root |
| deleteResource(root.getUnderlyingResource()); |
| |
| IIncludePathEntry[] newCP= project.getRawIncludepath(); |
| |
| try { |
| // should still be an entry for the "src" folder |
| assertTrue("classpath should not have been updated", |
| newCP.length == 2 && |
| newCP[0].equals(originalCP[0]) && |
| newCP[1].equals(originalCP[1])); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| /* |
| * Test classpath diamond (23979) |
| */ |
| public void testClasspathDiamond() throws CoreException { |
| try { |
| this.createJavaProject("P1", new String[]{""}); |
| this.createJavaProject("P2", new String[]{""}, new String[]{}, new String[]{"/P1"}); |
| this.createJavaProject("P3", new String[]{""}, new String[]{}, new String[]{"/P1", "/P2"}); |
| IJavaScriptProject p4 = this.createJavaProject("P4", new String[]{""}, new String[]{}, new String[]{"/P2", "/P3"}); |
| |
| assertTrue("Should not detect cycle", !p4.hasIncludepathCycle(null)); |
| |
| } finally { |
| // cleanup |
| this.deleteProjects(new String[] {"P1", "P2", "P3", "P4"}); |
| } |
| } |
| |
| /** |
| * Delete a nested root's parent folder and ensure the classpath is |
| * not updated (i.e. entry isn't removed). |
| */ |
| public void testClasspathDeleteNestedRootParent() throws CoreException { |
| IJavaScriptProject project = this.createJavaProject("P", new String[] {"nested/src"}, new String[] {}); |
| IPackageFragmentRoot root= getPackageFragmentRoot("P", "nested/src"); |
| IIncludePathEntry[] originalCP= project.getRawIncludepath(); |
| |
| // delete the root's parent folder |
| IFolder folder= (IFolder)root.getUnderlyingResource().getParent(); |
| deleteResource(folder); |
| |
| IIncludePathEntry[] newCP= project.getRawIncludepath(); |
| |
| try { |
| |
| // should still be an entry for the "src" folder |
| assertTrue("classpath should not have been updated", |
| newCP.length == 2 && |
| newCP[0].equals(originalCP[0]) && |
| newCP[1].equals(originalCP[1])); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| /** |
| * Test that a classpath entry for an external jar is externalized |
| * properly. |
| */ |
| public void testClasspathExternalize() throws CoreException { |
| try { |
| IJavaScriptProject project= this.createJavaProject("P", new String[] {}, new String[] {getSystemJsPathString()}); |
| IIncludePathEntry[] classpath= project.getRawIncludepath(); |
| IIncludePathEntry jar= null; |
| for (int i= 0; i < classpath.length; i++) { |
| if (classpath[i].getEntryKind() == IIncludePathEntry.CPE_LIBRARY) { |
| jar= classpath[i]; |
| break; |
| } |
| } |
| project.close(); |
| project.open(null); |
| |
| classpath= project.getRawIncludepath(); |
| for (int i= 0; i < classpath.length; i++) { |
| if (classpath[i].getEntryKind() == IIncludePathEntry.CPE_LIBRARY) { |
| assertTrue("Paths must be the same", classpath[i].getPath().equals(jar.getPath())); |
| break; |
| } |
| } |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| /** |
| * Move a root and ensure the classpath is not updated (i.e. entry not renamed). |
| */ |
| public void testClasspathMoveNestedRoot() throws CoreException { |
| IJavaScriptProject project = this.createJavaProject("P", new String[] {"nested/src"}, new String[] {}); |
| IPackageFragmentRoot root= getPackageFragmentRoot("P", "nested/src"); |
| IIncludePathEntry[] originalCP= project.getRawIncludepath(); |
| |
| // delete the root |
| IFolder folder= (IFolder)root.getUnderlyingResource(); |
| IPath originalPath= folder.getFullPath(); |
| IPath newPath= originalPath.removeLastSegments(1); |
| newPath= newPath.append(new Path("newsrc")); |
| |
| startDeltas(); |
| |
| folder.move(newPath, true, null); |
| |
| IIncludePathEntry[] newCP= project.getRawIncludepath(); |
| |
| IPackageFragmentRoot newRoot= project.getPackageFragmentRoot(project.getProject().getFolder("nested").getFolder("newsrc")); |
| |
| try { |
| // entry for the "src" folder wasn't replaced |
| assertTrue("classpath not automatically updated", newCP.length == 2 && |
| newCP[1].equals(originalCP[1]) && |
| newCP[0].equals(originalCP[0])); |
| |
| IJavaScriptElementDelta rootDelta = getDeltaFor(root, true); |
| IJavaScriptElementDelta projectDelta = getDeltaFor(newRoot.getParent(), true); |
| assertTrue("should get delta for moved root", rootDelta != null && |
| rootDelta.getKind() == IJavaScriptElementDelta.REMOVED && |
| rootDelta.getFlags() == 0); |
| assertTrue("should get delta indicating content changed for project", this.deltaContentChanged(projectDelta)); |
| |
| } finally { |
| stopDeltas(); |
| this.deleteProject("P"); |
| } |
| } |
| |
| /** |
| * Move a parent of a nested root and ensure the classpath is not updated (i.e. entry not renamed). |
| */ |
| public void testClasspathMoveNestedRootParent() throws CoreException { |
| try { |
| IJavaScriptProject project =this.createJavaProject("P", new String[] {"nested/src"}, new String[] {}); |
| IPackageFragmentRoot root= getPackageFragmentRoot("P", "nested/src"); |
| IIncludePathEntry[] originalCP= project.getRawIncludepath(); |
| |
| // delete the root |
| IFolder folder= (IFolder)root.getUnderlyingResource().getParent(); |
| IPath originalPath= folder.getFullPath(); |
| IPath newPath= originalPath.removeLastSegments(1); |
| newPath= newPath.append(new Path("newsrc")); |
| folder.move(newPath, true, null); |
| |
| IIncludePathEntry[] newCP= project.getRawIncludepath(); |
| |
| // entry for the "src" folder wasn't replaced |
| // entry for the "src" folder should not be replaced |
| assertTrue("classpath should not automatically be updated", newCP.length == 2 && |
| newCP[1].equals(originalCP[1]) && |
| newCP[0].equals(originalCP[0])); |
| |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| /** |
| * Tests that nothing occurs when setting to the same classpath |
| */ |
| public void testClasspathNoChanges() throws CoreException { |
| try { |
| IJavaScriptProject p = this.createJavaProject("P", new String[] {""}); |
| IIncludePathEntry[] oldClasspath= p.getRawIncludepath(); |
| startDeltas(); |
| p.setRawIncludepath(oldClasspath, null); |
| assertDeltas("Unexpected delta", ""); |
| } finally { |
| stopDeltas(); |
| this.deleteProject("P"); |
| } |
| } |
| /** |
| * Ensures that the setting the classpath with a reordered classpath generates |
| * the correct deltas. |
| */ |
| public void testClasspathReordering() throws CoreException { |
| IJavaScriptProject proj = this.createJavaProject("P", new String[] {"src"}, new String[] {getSystemJsPathString()}); |
| IIncludePathEntry[] originalCP = proj.getRawIncludepath(); |
| IPackageFragmentRoot root = getPackageFragmentRoot("P", "src"); |
| try { |
| IIncludePathEntry[] newEntries = new IIncludePathEntry[originalCP.length]; |
| int index = originalCP.length - 1; |
| for (int i = 0; i < originalCP.length; i++) { |
| newEntries[index] = originalCP[i]; |
| index--; |
| } |
| startDeltas(); |
| setClasspath(proj, newEntries); |
| assertTrue("should be one delta - two roots reordered", this.deltaListener.deltas.length == 1); |
| IJavaScriptElementDelta d = null; |
| assertTrue("root should be reordered in the classpath", (d = getDeltaFor(root, true)) != null |
| && (d.getFlags() & IJavaScriptElementDelta.F_REORDER) > 0); |
| } finally { |
| stopDeltas(); |
| this.deleteProject("P"); |
| } |
| } |
| |
| /** |
| * Should detect duplicate entries on the classpath |
| */ |
| public void testClasspathValidation01() throws CoreException { |
| try { |
| IJavaScriptProject proj = this.createJavaProject("P", new String[] {"src"}); |
| IIncludePathEntry[] originalCP = proj.getRawIncludepath(); |
| |
| IIncludePathEntry[] newCP = new IIncludePathEntry[originalCP.length+1]; |
| System.arraycopy(originalCP, 0, newCP, 0, originalCP.length); |
| newCP[originalCP.length] = newCP[0]; |
| |
| IJavaScriptModelStatus status = JavaScriptConventions.validateClasspath(proj, newCP); |
| |
| assertStatus( |
| "should have detected duplicate entries on the classpath", |
| "Include path contains duplicate entry: \'src\' for project P", |
| status); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| |
| /** |
| * Should detect nested source folders on the classpath |
| */ |
| public void testClasspathValidation02() throws CoreException { |
| try { |
| IJavaScriptProject proj = this.createJavaProject("P", new String[] {"src"}); |
| IIncludePathEntry[] originalCP = proj.getRawIncludepath(); |
| |
| IIncludePathEntry[] newCP = new IIncludePathEntry[originalCP.length+1]; |
| System.arraycopy(originalCP, 0, newCP, 0, originalCP.length); |
| newCP[originalCP.length] = JavaScriptCore.newSourceEntry(new Path("/P")); |
| |
| IJavaScriptModelStatus status = JavaScriptConventions.validateClasspath(proj, newCP); |
| |
| assertStatus( |
| "should have detected nested source folders on the classpath", |
| "Cannot nest \'P/src\' inside \'P\'. To enable the nesting exclude \'src/\' from \'P\'", |
| status); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| |
| /** |
| * Should detect library folder nested inside source folder on the classpath |
| */ |
| public void testClasspathValidation03() throws CoreException { |
| try { |
| IJavaScriptProject proj = this.createJavaProject("P", new String[] {"src"}); |
| IIncludePathEntry[] originalCP = proj.getRawIncludepath(); |
| |
| IIncludePathEntry[] newCP = new IIncludePathEntry[originalCP.length+1]; |
| System.arraycopy(originalCP, 0, newCP, 0, originalCP.length); |
| newCP[originalCP.length] = JavaScriptCore.newLibraryEntry(new Path("/P/src/lib"), null, null); |
| |
| IJavaScriptModelStatus status = JavaScriptConventions.validateClasspath(proj, newCP); |
| |
| assertStatus( |
| "should have detected library folder nested inside source folder on the classpath", |
| "Cannot nest \'P/src/lib\' inside \'P/src\'. To enable the nesting exclude \'lib/\' from \'P/src\'", |
| status); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| |
| public void testClasspathValidation04() throws CoreException { |
| |
| IJavaScriptProject[] p = null; |
| try { |
| |
| p = new IJavaScriptProject[]{ |
| this.createJavaProject("P0", new String[] {"src0"}), |
| this.createJavaProject("P1", new String[] {"src1"}), |
| }; |
| |
| JavaScriptCore.setIncludepathVariable("var", new Path("/P1"), null); |
| |
| IIncludePathEntry[] newClasspath = new IIncludePathEntry[]{ |
| JavaScriptCore.newSourceEntry(new Path("/P0/src0")), |
| JavaScriptCore.newVariableEntry(new Path("var/src1"), null, null), |
| }; |
| |
| // validate classpath |
| IJavaScriptModelStatus status = JavaScriptConventions.validateClasspath(p[0], newClasspath); |
| assertStatus( |
| "should not detect external source folder through a variable on the classpath", |
| "OK", |
| status); |
| |
| } finally { |
| this.deleteProjects(new String[] {"P0", "P1"}); |
| } |
| } |
| |
| public void testClasspathValidation05() throws CoreException { |
| |
| IJavaScriptProject[] p = null; |
| try { |
| |
| p = new IJavaScriptProject[]{ |
| this.createJavaProject("P0", new String[] {"src0", "src1"}), |
| this.createJavaProject("P1", new String[] {"src1"}), |
| }; |
| |
| JavaScriptCore.setJsGlobalScopeContainer( |
| new Path("container/default"), |
| new IJavaScriptProject[]{ p[0] }, |
| new IJsGlobalScopeContainer[] { |
| new TestContainer(new Path("container/default"), |
| new IIncludePathEntry[]{ |
| JavaScriptCore.newSourceEntry(new Path("/P0/src0")), |
| JavaScriptCore.newVariableEntry(new Path("var/src1"), null, null) }) |
| }, |
| null); |
| |
| IIncludePathEntry[] newClasspath = new IIncludePathEntry[]{ |
| JavaScriptCore.newSourceEntry(new Path("/P0/src1")), |
| JavaScriptCore.newContainerEntry(new Path("container/default")), |
| }; |
| |
| // validate classpath |
| IJavaScriptModelStatus status = JavaScriptConventions.validateClasspath(p[0], newClasspath); |
| assertStatus( |
| "should not have detected external source folder through a container on the classpath", |
| "OK", |
| status); |
| |
| // validate classpath entry |
| status = JavaScriptConventions.validateClasspathEntry(p[0], newClasspath[1], true); |
| assertStatus( |
| "should have detected external source folder through a container on the classpath", |
| "Invalid classpath container: \'container/default\' in project P0", |
| status); |
| |
| } finally { |
| this.deleteProjects(new String[] {"P0", "P1"}); |
| } |
| } |
| |
| public void testClasspathValidation06() throws CoreException { |
| |
| IJavaScriptProject[] p = null; |
| try { |
| |
| p = new IJavaScriptProject[]{ |
| this.createJavaProject("P0", new String[] {"src"}), |
| }; |
| |
| // validate classpath entry |
| IIncludePathEntry[] newClasspath = new IIncludePathEntry[]{ |
| JavaScriptCore.newSourceEntry(new Path("/P0")), |
| JavaScriptCore.newSourceEntry(new Path("/P0/src")), |
| }; |
| |
| IJavaScriptModelStatus status = JavaScriptConventions.validateClasspath(p[0], newClasspath); |
| assertStatus( |
| "should have detected nested source folder", |
| "Cannot nest \'P0/src\' inside \'P0\'. To enable the nesting exclude \'src/\' from \'P0\'", |
| status); |
| } finally { |
| this.deleteProject("P0"); |
| } |
| } |
| /** |
| * Should allow nested source folders on the classpath as long as the outer |
| * folder excludes the inner one. |
| */ |
| public void testClasspathValidation07() throws CoreException { |
| try { |
| IJavaScriptProject proj = this.createJavaProject("P", new String[] {"src"}); |
| IIncludePathEntry[] originalCP = proj.getRawIncludepath(); |
| |
| IIncludePathEntry[] newCP = new IIncludePathEntry[originalCP.length+1]; |
| System.arraycopy(originalCP, 0, newCP, 0, originalCP.length); |
| newCP[originalCP.length] = JavaScriptCore.newSourceEntry(new Path("/P"), new IPath[] {new Path("src/")}); |
| |
| IJavaScriptModelStatus status = JavaScriptConventions.validateClasspath(proj, newCP); |
| |
| assertStatus( |
| "should have allowed nested source folders with exclusion on the classpath", |
| "OK", |
| status); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| /** |
| * Should allow a nested binary folder in a source folder on the classpath as |
| * long as the outer folder excludes the inner one. |
| */ |
| public void testClasspathValidation08() throws CoreException { |
| try { |
| IJavaScriptProject proj = this.createJavaProject("P", new String[] {}, new String[] {"lib"}); |
| IIncludePathEntry[] originalCP = proj.getRawIncludepath(); |
| |
| IIncludePathEntry[] newCP = new IIncludePathEntry[originalCP.length+1]; |
| System.arraycopy(originalCP, 0, newCP, 0, originalCP.length); |
| newCP[originalCP.length] = JavaScriptCore.newSourceEntry(new Path("/P"), new IPath[] {new Path("lib/")}); |
| |
| IJavaScriptModelStatus status = JavaScriptConventions.validateClasspath(proj, newCP); |
| |
| assertStatus( |
| "should have allowed nested lib folders with exclusion on the classpath", |
| "OK", |
| status); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| /** |
| * Should not allow nested source folders on the classpath if exclusion filter has no trailing slash. |
| */ |
| public void testClasspathValidation15() throws CoreException { |
| try { |
| IJavaScriptProject proj = this.createJavaProject("P", new String[] {"src"}); |
| IIncludePathEntry[] originalCP = proj.getRawIncludepath(); |
| |
| IIncludePathEntry[] newCP = new IIncludePathEntry[originalCP.length+1]; |
| System.arraycopy(originalCP, 0, newCP, 0, originalCP.length); |
| newCP[originalCP.length] = JavaScriptCore.newSourceEntry(new Path("/P"), new IPath[] {new Path("**/src")}); |
| |
| IJavaScriptModelStatus status = JavaScriptConventions.validateClasspath(proj, newCP); |
| |
| assertStatus( |
| "End exclusion filter \'src\' with / to fully exclude \'P/src\'", |
| status); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| /** |
| * Should detect source folder nested inside library folder on the classpath |
| */ |
| public void testClasspathValidation19() throws CoreException { |
| try { |
| IJavaScriptProject proj = this.createJavaProject("P", new String[] {}, new String[] {"lib"}); |
| IIncludePathEntry[] originalCP = proj.getRawIncludepath(); |
| |
| IIncludePathEntry[] newCP = new IIncludePathEntry[originalCP.length+1]; |
| System.arraycopy(originalCP, 0, newCP, 0, originalCP.length); |
| newCP[originalCP.length] = JavaScriptCore.newSourceEntry(new Path("/P/lib/src")); |
| |
| IJavaScriptModelStatus status = JavaScriptConventions.validateClasspath(proj, newCP); |
| |
| assertStatus( |
| "should have detected library folder nested inside source folder on the classpath", |
| "Cannot nest \'P/lib/src\' inside library \'P/lib\'", |
| status); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| /** |
| * Should not allow exclusion patterns if project preference disallow them |
| */ |
| public void testClasspathValidation21() throws CoreException { |
| try { |
| IJavaScriptProject proj = this.createJavaProject("P", new String[] {}); |
| IIncludePathEntry[] originalCP = proj.getRawIncludepath(); |
| |
| IIncludePathEntry[] newCP = new IIncludePathEntry[originalCP.length+1]; |
| System.arraycopy(originalCP, 0, newCP, 0, originalCP.length); |
| newCP[originalCP.length] = JavaScriptCore.newSourceEntry(new Path("/P/src"), new IPath[]{new Path("**/src")}, null); |
| |
| Map options = new Hashtable(5); |
| options.put(JavaScriptCore.CORE_ENABLE_CLASSPATH_EXCLUSION_PATTERNS, JavaScriptCore.DISABLED); |
| proj.setOptions(options); |
| IJavaScriptModelStatus status = JavaScriptConventions.validateClasspath(proj, newCP); |
| |
| assertStatus( |
| "Inclusion or exclusion patterns are disabled in project P, cannot selectively include or exclude from entry: \'src\'", |
| status); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| /** |
| * @bug 159325: Any idea why ClasspathEntry checks for string object reference instead of equals |
| * @test Ensure that validation is correctly done even for other strings than JavaScriptCore constants... |
| * Note that it's needed to change JavaScriptCore options as "ignore" is the default value and set option |
| * to this value on java project will just remove it instead of putting another string object... |
| * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=159325" |
| */ |
| public void testClasspathValidation27_Bug159325_project() throws CoreException { |
| Hashtable javaCoreOptions = JavaScriptCore.getOptions(); |
| try { |
| IJavaScriptProject proj1 = this.createJavaProject("P1", new String[] {}); |
| proj1.setOption(JavaScriptCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaScriptCore.VERSION_1_4); |
| |
| Hashtable options = JavaScriptCore.getOptions(); |
| options.put(JavaScriptCore.CORE_INCOMPATIBLE_JDK_LEVEL, JavaScriptCore.WARNING); |
| JavaScriptCore.setOptions(options); |
| IJavaScriptProject proj2 = this.createJavaProject("P2", new String[] {}); |
| proj2.setOption(JavaScriptCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaScriptCore.VERSION_1_1); |
| proj2.setOption(JavaScriptCore.CORE_INCOMPATIBLE_JDK_LEVEL, new String("ignore".toCharArray())); |
| |
| IJavaScriptModelStatus status = JavaScriptConventions.validateClasspathEntry(proj2, JavaScriptCore.newProjectEntry(new Path("/P1")), false); |
| assertStatus("OK", status); |
| } finally { |
| JavaScriptCore.setOptions(javaCoreOptions); |
| this.deleteProjects(new String[]{"P1", "P2"}); |
| } |
| } |
| public void testClasspathValidation27_Bug159325_lib() throws CoreException { |
| Hashtable javaCoreOptions = JavaScriptCore.getOptions(); |
| try { |
| IJavaScriptProject proj = this.createJavaProject("P1", new String[] {}); |
| proj.setOption(JavaScriptCore.COMPILER_CODEGEN_TARGET_PLATFORM, JavaScriptCore.VERSION_1_1); |
| |
| Hashtable options = JavaScriptCore.getOptions(); |
| options.put(JavaScriptCore.CORE_INCOMPATIBLE_JDK_LEVEL, JavaScriptCore.WARNING); |
| JavaScriptCore.setOptions(options); |
| proj.setOption(JavaScriptCore.CORE_INCOMPATIBLE_JDK_LEVEL, new String("ignore".toCharArray())); |
| |
| IIncludePathEntry library = JavaScriptCore.newLibraryEntry(new Path(getExternalJCLPathString(JavaScriptCore.VERSION_1_5)), null, null, ClasspathEntry.NO_ACCESS_RULES, null, false); |
| IJavaScriptModelStatus status = JavaScriptConventions.validateClasspathEntry(proj, library, false); |
| assertStatus("OK", status); |
| } finally { |
| JavaScriptCore.setOptions(javaCoreOptions); |
| this.deleteProjects(new String[]{"P1", "P2"}); |
| } |
| } |
| /** |
| * Should not allow nested source folders on the classpath if the outer |
| * folder includes the inner one. |
| */ |
| public void testClasspathValidation34() throws CoreException { |
| try { |
| IJavaScriptProject proj = this.createJavaProject("P", new String[] {"src"}); |
| IIncludePathEntry[] originalCP = proj.getRawIncludepath(); |
| |
| IIncludePathEntry[] newCP = new IIncludePathEntry[originalCP.length+1]; |
| System.arraycopy(originalCP, 0, newCP, 0, originalCP.length); |
| newCP[originalCP.length] = JavaScriptCore.newSourceEntry(new Path("/P"), new IPath[] {new Path("src/")}, new IPath[0], null); |
| |
| IJavaScriptModelStatus status = JavaScriptConventions.validateClasspath(proj, newCP); |
| |
| assertStatus( |
| "should not have allowed nested source folders with inclusion on the classpath", |
| "Cannot nest \'P/src\' inside \'P\'. To enable the nesting exclude \'src/\' from \'P\'", |
| status); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| |
| /** |
| * Should not allow a nested binary folder in a source folder on the classpath |
| * if the outer folder includes the inner one. |
| */ |
| public void testClasspathValidation35() throws CoreException { |
| try { |
| IJavaScriptProject proj = this.createJavaProject("P", new String[] {}, new String[] {"lib"}); |
| IIncludePathEntry[] originalCP = proj.getRawIncludepath(); |
| |
| IIncludePathEntry[] newCP = new IIncludePathEntry[originalCP.length+1]; |
| System.arraycopy(originalCP, 0, newCP, 0, originalCP.length); |
| newCP[originalCP.length] = JavaScriptCore.newSourceEntry(new Path("/P"), new IPath[] {new Path("lib/")}, new Path[0], null); |
| |
| IJavaScriptModelStatus status = JavaScriptConventions.validateClasspath(proj, newCP); |
| |
| assertStatus( |
| "should not have allowed nested lib folders with inclusion on the classpath", |
| "Cannot nest \'P/lib\' inside \'P\'. To enable the nesting exclude \'lib/\' from \'P\'", |
| status); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| |
| /** |
| * Should allow nested source folders on the classpath if inclusion filter has no trailing slash. |
| */ |
| public void testClasspathValidation36() throws CoreException { |
| try { |
| IJavaScriptProject proj = this.createJavaProject("P", new String[] {"src"}); |
| IIncludePathEntry[] originalCP = proj.getRawIncludepath(); |
| |
| IIncludePathEntry[] newCP = new IIncludePathEntry[originalCP.length+1]; |
| System.arraycopy(originalCP, 0, newCP, 0, originalCP.length); |
| newCP[originalCP.length] = JavaScriptCore.newSourceEntry(new Path("/P"), new IPath[] {new Path("**/src")}, new Path[0], null); |
| |
| IJavaScriptModelStatus status = JavaScriptConventions.validateClasspath(proj, newCP); |
| |
| assertStatus( |
| "OK", |
| status); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| /** |
| * Should not allow inclusion patterns if project preference disallow them |
| */ |
| public void testClasspathValidation37() throws CoreException { |
| try { |
| IJavaScriptProject proj = this.createJavaProject("P", new String[] {}); |
| IIncludePathEntry[] originalCP = proj.getRawIncludepath(); |
| |
| IIncludePathEntry[] newCP = new IIncludePathEntry[originalCP.length+1]; |
| System.arraycopy(originalCP, 0, newCP, 0, originalCP.length); |
| newCP[originalCP.length] = JavaScriptCore.newSourceEntry(new Path("/P/src"), new IPath[]{new Path("**/src")}, new Path[0], null); |
| |
| Map options = new Hashtable(5); |
| options.put(JavaScriptCore.CORE_ENABLE_CLASSPATH_EXCLUSION_PATTERNS, JavaScriptCore.DISABLED); |
| proj.setOptions(options); |
| IJavaScriptModelStatus status = JavaScriptConventions.validateClasspath(proj, newCP); |
| |
| assertStatus( |
| "Inclusion or exclusion patterns are disabled in project P, cannot selectively include or exclude from entry: \'src\'", |
| status); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| /* |
| * Should detect nested source folders on the classpath and indicate the preference if disabled |
| * (regression test for bug 122615 validate classpath propose to exlude a source folder even though exlusion patterns are disabled) |
| */ |
| public void testClasspathValidation42() throws CoreException { |
| try { |
| IJavaScriptProject proj = this.createJavaProject("P", new String[] {"src"}); |
| proj.setOption(JavaScriptCore.CORE_ENABLE_CLASSPATH_EXCLUSION_PATTERNS, JavaScriptCore.DISABLED); |
| IIncludePathEntry[] originalCP = proj.getRawIncludepath(); |
| |
| IIncludePathEntry[] newCP = new IIncludePathEntry[originalCP.length+1]; |
| System.arraycopy(originalCP, 0, newCP, 0, originalCP.length); |
| newCP[originalCP.length] = JavaScriptCore.newSourceEntry(new Path("/P")); |
| |
| IJavaScriptModelStatus status = JavaScriptConventions.validateClasspath(proj, newCP); |
| |
| assertStatus( |
| "should have detected nested source folders on the classpath", |
| "Cannot nest \'P/src\' inside \'P\'. To allow the nesting enable use of exclusion patterns in the preferences of project \'P\' and exclude \'src/\' from \'P\'", |
| status); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| /** |
| * Setting the classpath with two entries specifying the same path |
| * should fail. |
| */ |
| public void testClasspathWithDuplicateEntries() throws CoreException { |
| try { |
| IJavaScriptProject project = this.createJavaProject("P", new String[] {"src"}); |
| IIncludePathEntry[] cp= project.getRawIncludepath(); |
| IIncludePathEntry[] newCp= new IIncludePathEntry[cp.length *2]; |
| System.arraycopy(cp, 0, newCp, 0, cp.length); |
| System.arraycopy(cp, 0, newCp, cp.length, cp.length); |
| try { |
| project.setRawIncludepath(newCp, null); |
| } catch (JavaScriptModelException jme) { |
| return; |
| } |
| assertTrue("Setting the classpath with two entries specifying the same path should fail", false); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| /** |
| * Bug 94404: [model] Disallow classpath attributes with same key |
| * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=94404" |
| */ |
| public void testClasspathDuplicateExtraAttribute() throws CoreException { |
| try { |
| IJavaScriptProject proj = this.createJavaProject("P1", new String[] {}); |
| IIncludePathAttribute[] extraAttributes = new IIncludePathAttribute[2]; |
| extraAttributes[0] = JavaScriptCore.newIncludepathAttribute("javadoc_location", "http://www.sample-url.org/doc/"); |
| extraAttributes[1] = JavaScriptCore.newIncludepathAttribute("javadoc_location", "d:/tmp"); |
| |
| // Verify container entry validation |
| IIncludePathEntry container = JavaScriptCore.newContainerEntry(new Path("JRE_CONTAINER"), ClasspathEntry.NO_ACCESS_RULES, extraAttributes, false); |
| IJavaScriptModelStatus status = JavaScriptConventions.validateClasspathEntry(proj, container, false); |
| assertStatus( |
| "Duplicate extra attribute: \'javadoc_location\' in classpath entry \'JRE_CONTAINER\' for project 'P1'", |
| status); |
| |
| // Verify library entry validation |
| IIncludePathEntry library = JavaScriptCore.newLibraryEntry(new Path(getSystemJsPathString()), null, null, ClasspathEntry.NO_ACCESS_RULES, extraAttributes, false); |
| status = JavaScriptConventions.validateClasspathEntry(proj, library, false); |
| assertStatus( |
| "Duplicate extra attribute: \'javadoc_location\' in classpath entry \'"+getExternalJCLPath("")+"\' for project 'P1'", |
| status); |
| |
| // Verify project entry validation |
| createJavaProject("P2"); |
| IIncludePathEntry projectEntry = JavaScriptCore.newProjectEntry(new Path("/P2"), ClasspathEntry.NO_ACCESS_RULES, false, extraAttributes, false); |
| status = JavaScriptConventions.validateClasspathEntry(proj, projectEntry, false); |
| assertStatus( |
| "Duplicate extra attribute: \'javadoc_location\' in classpath entry \'/P2\' for project 'P1'", |
| status); |
| |
| // Verify source entry validation |
| createFolder("/P1/src"); |
| IIncludePathEntry sourceEntry = JavaScriptCore.newSourceEntry(new Path("/P1/src"), new IPath[0], new IPath[0], null, extraAttributes); |
| status = JavaScriptConventions.validateClasspathEntry(proj, sourceEntry, false); |
| assertStatus( |
| "Duplicate extra attribute: \'javadoc_location\' in classpath entry \'src\' for project 'P1'", |
| status); |
| |
| // Verify variable entry validation |
| IIncludePathEntry variable = JavaScriptCore.newVariableEntry(new Path("JCL_LIB"), new Path("JCL_SRC"), null, ClasspathEntry.NO_ACCESS_RULES, extraAttributes, false); |
| status = JavaScriptConventions.validateClasspathEntry(proj, variable, false); |
| assertStatus( |
| "Duplicate extra attribute: \'javadoc_location\' in classpath entry \'"+getExternalJCLPath("")+"\' for project 'P1'", |
| status); |
| } finally { |
| this.deleteProject("P1"); |
| this.deleteProject("P2"); |
| } |
| } |
| |
| /** |
| * Adding an entry to the classpath for a library that does not exist |
| * should not break the model. The classpath should contain the |
| * entry, but the root should not appear in the children. |
| */ |
| public void testClasspathWithNonExistentLibraryEntry() throws CoreException { |
| try { |
| IJavaScriptProject project= this.createJavaProject("P", new String[] {"src"}); |
| IIncludePathEntry[] originalPath= project.getRawIncludepath(); |
| IPackageFragmentRoot[] originalRoots= project.getPackageFragmentRoots(); |
| |
| IIncludePathEntry[] newPath= new IIncludePathEntry[originalPath.length + 1]; |
| System.arraycopy(originalPath, 0, newPath, 0, originalPath.length); |
| |
| IIncludePathEntry newEntry= JavaScriptCore.newLibraryEntry(new Path("c:/nothing/nozip.jar").makeAbsolute(), null, null, false); |
| newPath[originalPath.length]= newEntry; |
| |
| project.setRawIncludepath(newPath, null); |
| |
| IIncludePathEntry[] getPath= project.getRawIncludepath(); |
| assertTrue("should be the same length", getPath.length == newPath.length); |
| for (int i= 0; i < getPath.length; i++) { |
| assertTrue("entries should be the same", getPath[i].equals(newPath[i])); |
| } |
| |
| IPackageFragmentRoot[] newRoots= project.getPackageFragmentRoots(); |
| assertTrue("Should be the same number of roots", originalRoots.length == newRoots.length); |
| for (int i= 0; i < newRoots.length; i++) { |
| assertTrue("roots should be the same", originalRoots[i].equals(newRoots[i])); |
| } |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| /** |
| * Adding an entry to the classpath for a project that does not exist |
| * should not break the model. The classpath should contain the |
| * entry, but the root should not appear in the children. |
| */ |
| public void testClasspathWithNonExistentProjectEntry() throws CoreException { |
| try { |
| IJavaScriptProject project= this.createJavaProject("P", new String[] {"src"}); |
| IIncludePathEntry[] originalPath= project.getRawIncludepath(); |
| IPackageFragmentRoot[] originalRoots= project.getPackageFragmentRoots(); |
| |
| IIncludePathEntry[] newPath= new IIncludePathEntry[originalPath.length + 1]; |
| System.arraycopy(originalPath, 0, newPath, 0, originalPath.length); |
| |
| IIncludePathEntry newEntry= JavaScriptCore.newProjectEntry(new Path("/NoProject"), false); |
| newPath[originalPath.length]= newEntry; |
| |
| project.setRawIncludepath(newPath, null); |
| |
| IIncludePathEntry[] getPath= project.getRawIncludepath(); |
| assertTrue("should be the same length", getPath.length == newPath.length); |
| for (int i= 0; i < getPath.length; i++) { |
| assertTrue("entries should be the same", getPath[i].equals(newPath[i])); |
| } |
| |
| IPackageFragmentRoot[] newRoots= project.getPackageFragmentRoots(); |
| assertTrue("Should be the same number of roots", originalRoots.length == newRoots.length); |
| for (int i= 0; i < newRoots.length; i++) { |
| assertTrue("roots should be the same", originalRoots[i].equals(newRoots[i])); |
| } |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| /** |
| * Adding an entry to the classpath for a folder that does not exist |
| * should not break the model. The classpath should contain the |
| * entry, but the root should not appear in the children. |
| */ |
| public void testClasspathWithNonExistentSourceEntry() throws CoreException { |
| try { |
| IJavaScriptProject project= this.createJavaProject("P", new String[] {"src"}); |
| IIncludePathEntry[] originalPath= project.getRawIncludepath(); |
| IPackageFragmentRoot[] originalRoots= project.getPackageFragmentRoots(); |
| |
| IIncludePathEntry[] newPath= new IIncludePathEntry[originalPath.length + 1]; |
| System.arraycopy(originalPath, 0, newPath, 0, originalPath.length); |
| |
| IIncludePathEntry newEntry= JavaScriptCore.newSourceEntry(new Path("/P/moreSource")); |
| newPath[originalPath.length]= newEntry; |
| |
| project.setRawIncludepath(newPath, null); |
| |
| IIncludePathEntry[] getPath= project.getRawIncludepath(); |
| assertTrue("should be the same length", getPath.length == newPath.length); |
| for (int i= 0; i < getPath.length; i++) { |
| assertTrue("entries should be the same", getPath[i].equals(newPath[i])); |
| } |
| |
| IPackageFragmentRoot[] newRoots= project.getPackageFragmentRoots(); |
| assertTrue("Should be the same number of roots", originalRoots.length == newRoots.length); |
| for (int i= 0; i < newRoots.length; i++) { |
| assertTrue("roots should be the same", originalRoots[i].equals(newRoots[i])); |
| } |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| |
| /** |
| * Ensure that cycle are properly reported. |
| */ |
| public void testCycleReport() throws CoreException { |
| |
| try { |
| IJavaScriptProject p1 = this.createJavaProject("P1", new String[] {""}); |
| IJavaScriptProject p2 = this.createJavaProject("P2", new String[] {""}); |
| IJavaScriptProject p3 = this.createJavaProject("P3", new String[] {""}, new String[] {}, new String[] {"/P2"}); |
| |
| // Ensure no cycle reported |
| IJavaScriptProject[] projects = { p1, p2, p3 }; |
| int cycleMarkerCount = 0; |
| for (int i = 0; i < projects.length; i++){ |
| cycleMarkerCount += this.numberOfCycleMarkers(projects[i]); |
| } |
| assertTrue("Should have no cycle markers", cycleMarkerCount == 0); |
| |
| // Add cycle |
| IIncludePathEntry[] originalP1CP= p1.getRawIncludepath(); |
| IIncludePathEntry[] originalP2CP= p2.getRawIncludepath(); |
| |
| // Add P1 as a prerequesite of P2 |
| int length = originalP2CP.length; |
| IIncludePathEntry[] newCP= new IIncludePathEntry[length + 1]; |
| System.arraycopy(originalP2CP, 0 , newCP, 0, length); |
| newCP[length]= JavaScriptCore.newProjectEntry(p1.getProject().getFullPath(), false); |
| p2.setRawIncludepath(newCP, null); |
| |
| // Add P3 as a prerequesite of P1 |
| length = originalP1CP.length; |
| newCP= new IIncludePathEntry[length + 1]; |
| System.arraycopy(originalP1CP, 0 , newCP, 0, length); |
| newCP[length]= JavaScriptCore.newProjectEntry(p3.getProject().getFullPath(), false); |
| p1.setRawIncludepath(newCP, null); |
| |
| waitForAutoBuild(); // wait for cycle markers to be created |
| cycleMarkerCount = 0; |
| for (int i = 0; i < projects.length; i++){ |
| cycleMarkerCount += numberOfCycleMarkers(projects[i]); |
| } |
| assertEquals("Unexpected number of projects involved in a classpath cycle", 3, cycleMarkerCount); |
| |
| } finally { |
| // cleanup |
| deleteProjects(new String[] {"P1", "P2", "P3"}); |
| } |
| } |
| /** |
| * Ensures that the default classpath locations are correct. |
| * The default classpath should be the root of the project. |
| */ |
| public void testDefaultClasspathLocation() throws CoreException { |
| try { |
| IJavaScriptProject project = this.createJavaProject("P", new String[] {""}); |
| IIncludePathEntry[] classpath = project.getRawIncludepath(); |
| assertTrue("Incorrect default classpath; to many entries", classpath.length == 2); |
| assertTrue("Incorrect default classpath: " + classpath[0], classpath[0].getPath().equals(project.getUnderlyingResource().getFullPath())); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| |
| /** |
| * Setting the classpath to empty should result in no entries, |
| * and a delta with removed roots. |
| */ |
| public void testEmptyClasspath() throws CoreException { |
| IJavaScriptProject project = this.createJavaProject("P", new String[] {""}); |
| try { |
| startDeltas(); |
| setClasspath(project, new IIncludePathEntry[] {}); |
| IIncludePathEntry[] cp= project.getRawIncludepath(); |
| assertTrue("classpath should have no entries", cp.length == 0); |
| |
| // ensure the deltas are correct |
| assertDeltas( |
| "Unexpected delta", |
| "P[*]: {CHILDREN | CONTENT | CLASSPATH CHANGED}\n" + |
| " <project root>[*]: {REMOVED FROM CLASSPATH}\n" + |
| " D:\\WTPDevelopment\\junit-workspace\\.metadata\\.plugins\\org.eclipse.wst.jsdt.core\\libraries\\system.js[*]: {REORDERED}\n" + |
| " ResourceDelta(/P/.settings)[*]" |
| ); |
| } finally { |
| stopDeltas(); |
| this.deleteProject("P"); |
| } |
| } |
| /* |
| * Ensures that a source folder that contains character that must be encoded can be written. |
| * (regression test for bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=70193) |
| */ |
| public void testEncoding() throws CoreException { |
| try { |
| createJavaProject("P", new String[] {"src\u3400"}); |
| IFile file = getFile("/P/.settings/.jsdtscope"); |
| String encodedContents = new String (org.eclipse.wst.jsdt.internal.core.util.Util.getResourceContentsAsCharArray(file, "UTF-8")); |
| encodedContents = Util.convertToIndependantLineDelimiter(encodedContents); |
| assertEquals( |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry kind=\"src\" path=\"src\u3400\"/>\n" + |
| " <classpathentry kind=\"con\" path=\"org.eclipse.wst.jsdt.launching.JRE_CONTAINER\"/>\n" + |
| " <classpathentry kind=\"output\" path=\"\"/>\n" + |
| "</classpath>\n", |
| encodedContents); |
| } finally { |
| deleteProject("P"); |
| } |
| } |
| /* |
| * Ensures that a source classpath entry can be encoded and decoded. |
| */ |
| public void testEncodeDecodeEntry01() { |
| assertEncodeDecodeEntry( |
| "P", |
| "<classpathentry kind=\"src\" path=\"src\"/>\n", |
| JavaScriptCore.newSourceEntry(new Path("/P/src")) |
| ); |
| } |
| /* |
| * Ensures that a source classpath entry with all possible attributes can be encoded and decoded. |
| */ |
| public void testEncodeDecodeEntry02() { |
| assertEncodeDecodeEntry( |
| "P", |
| "<classpathentry excluding=\"**/X.js\" including=\"**/Y.js\" kind=\"src\" output=\"bin\" path=\"src\">\n" + |
| " <attributes>\n" + |
| " <attribute name=\"attrName\" value=\"some value\"/>\n" + |
| " </attributes>\n" + |
| "</classpathentry>\n", |
| JavaScriptCore.newSourceEntry( |
| new Path("/P/src"), |
| new IPath[] {new Path("**/Y.js")}, |
| new IPath[] {new Path("**/X.js")}, |
| new Path("/P/bin"), |
| new IIncludePathAttribute[] {JavaScriptCore.newIncludepathAttribute("attrName", "some value")}) |
| ); |
| } |
| /* |
| * Ensures that a project classpath entry can be encoded and decoded. |
| */ |
| public void testEncodeDecodeEntry03() { |
| assertEncodeDecodeEntry( |
| "P1", |
| "<classpathentry kind=\"src\" path=\"/P2\"/>\n", |
| JavaScriptCore.newProjectEntry(new Path("/P2")) |
| ); |
| } |
| /* |
| * Ensures that a library classpath entry can be encoded and decoded. |
| */ |
| public void testEncodeDecodeEntry04() { |
| assertEncodeDecodeEntry( |
| "P", |
| "<classpathentry exported=\"true\" kind=\"lib\" path=\"lib.jar\" rootpath=\"root\" sourcepath=\"src.zip\">\n" + |
| " <attributes>\n" + |
| " <attribute name=\"attr1\" value=\"val1\"/>\n" + |
| " </attributes>\n" + |
| " <accessrules>\n" + |
| " <accessrule kind=\"accessible\" pattern=\"**/A*.js\"/>\n" + |
| " </accessrules>\n" + |
| "</classpathentry>\n", |
| JavaScriptCore.newLibraryEntry( |
| new Path("/P/lib.jar"), |
| new Path("/P/src.zip"), |
| new Path("root"), |
| new IAccessRule[] {JavaScriptCore.newAccessRule(new Path("**/A*.js"), IAccessRule.K_ACCESSIBLE)}, |
| new IIncludePathAttribute[] {JavaScriptCore.newIncludepathAttribute("attr1", "val1")}, |
| true) |
| ); |
| } |
| /* |
| * Ensures that a library classpath entry can be encoded and decoded. |
| */ |
| public void testEncodeDecodeEntry05() { |
| assertEncodeDecodeEntry( |
| "P", |
| "<classpathentry exported=\"true\" kind=\"lib\" path=\"lib.jar\" rootpath=\"root\" sourcepath=\"src.zip\">\n" + |
| " <attributes>\n" + |
| " <attribute name=\"attr1\" value=\"val1\"/>\n" + |
| " </attributes>\n" + |
| " <accessrules>\n" + |
| " <accessrule ignoreifbetter=\"true\" kind=\"accessible\" pattern=\"**/A*.js\"/>\n" + |
| " </accessrules>\n" + |
| "</classpathentry>\n", |
| JavaScriptCore.newLibraryEntry( |
| new Path("/P/lib.jar"), |
| new Path("/P/src.zip"), |
| new Path("root"), |
| new IAccessRule[] {JavaScriptCore.newAccessRule(new Path("**/A*.js"), IAccessRule.K_ACCESSIBLE | IAccessRule.IGNORE_IF_BETTER)}, |
| new IIncludePathAttribute[] {JavaScriptCore.newIncludepathAttribute("attr1", "val1")}, |
| true) |
| ); |
| } |
| /** |
| * Ensures that adding an empty classpath container |
| * generates the correct deltas. |
| */ |
| public void testEmptyContainer() throws CoreException { |
| try { |
| IJavaScriptProject proj = createJavaProject("P", new String[] {}); |
| |
| startDeltas(); |
| |
| // create container |
| JavaScriptCore.setJsGlobalScopeContainer( |
| new Path("container/default"), |
| new IJavaScriptProject[]{ proj }, |
| new IJsGlobalScopeContainer[] { |
| new TestContainer( |
| new Path("container/default"), |
| new IIncludePathEntry[] {}) |
| }, |
| null); |
| |
| // set P's classpath with this container |
| IIncludePathEntry container = JavaScriptCore.newContainerEntry(new Path("container/default"), true); |
| proj.setRawIncludepath(new IIncludePathEntry[] {container}, null); |
| |
| assertDeltas( |
| "Unexpected delta", |
| "P[*]: {CONTENT | CLASSPATH CHANGED}\n" + |
| " D:\\WTPDevelopment\\junit-workspace\\.metadata\\.plugins\\org.eclipse.wst.jsdt.core\\libraries\\system.js[*]: {REORDERED}\n" + |
| " ResourceDelta(/P/.classpath)[*]" |
| ); |
| } finally { |
| stopDeltas(); |
| this.deleteProject("P"); |
| } |
| } |
| /* |
| * Ensure that a .classpath with an empty inclusion pattern is correctly handled |
| * (regression test for bug 105581 Creating a Java project from existing source fails because of "Unhandled event loop exception":) |
| */ |
| public void testEmptyInclusionPattern() throws CoreException { |
| try { |
| IJavaScriptProject project = createJavaProject("P", new String[] {""}); |
| project.open(null); |
| editFile( |
| "/P/.settings/.jsdtscope", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry including=\"X.java|\" kind=\"src\" path=\"\"/>\n" + |
| " <classpathentry kind=\"output\" path=\"bin\"/>\n" + |
| "</classpath>" |
| ); |
| project.getProject().close(null); |
| project.getProject().open(null); |
| project.getPackageFragmentRoot(project.getProject()).open(null); |
| IIncludePathEntry[] classpath = project.getRawIncludepath(); |
| assertClasspathEquals( |
| classpath, |
| "/P[CPE_SOURCE][K_SOURCE][isExported:false][including:X.java]" |
| ); |
| } finally { |
| deleteProject("P"); |
| } |
| } |
| /** |
| * Exporting a container should make it visible to its dependent project. |
| * (regression test for bug 21749 Exported libraries and source folders) |
| */ |
| public void testExportContainer() throws CoreException { |
| try { |
| IJavaScriptProject p1 = this.createJavaProject("P1", new String[] {""}); |
| |
| // create container |
| JavaScriptCore.setJsGlobalScopeContainer( |
| new Path("container/default"), |
| new IJavaScriptProject[]{ p1 }, |
| new IJsGlobalScopeContainer[] { |
| new TestContainer( |
| new Path("container/default"), |
| new IIncludePathEntry[] { |
| JavaScriptCore.newLibraryEntry(getExternalJCLPath(""), null, null) |
| }) |
| }, |
| null); |
| |
| // set P1's classpath with this container |
| IIncludePathEntry container = JavaScriptCore.newContainerEntry(new Path("container/default"), true); |
| p1.setRawIncludepath(new IIncludePathEntry[] {container}, null); |
| |
| // create dependent project P2 |
| IJavaScriptProject p2 = this.createJavaProject("P2", new String[] {}, new String[] {}, new String[] {"/P1"}); |
| IIncludePathEntry[] classpath = ((JavaProject)p2).getExpandedClasspath(); |
| |
| // ensure container is exported to P2 |
| assertEquals("Unexpected number of classpath entries", 2, classpath.length); |
| assertEquals("Unexpected first entry", "/P1", classpath[0].getPath().toString()); |
| assertEquals("Unexpected second entry", getSystemJsPathString(), classpath[1].getPath().toOSString()); |
| } finally { |
| this.deleteProjects(new String[] {"P1", "P2"}); |
| } |
| } |
| /* |
| * Ensures that setting 0 extra classpath attributes generates the correct .classpath file. |
| */ |
| public void testExtraAttributes1() throws CoreException { |
| try { |
| IJavaScriptProject project = createJavaProject("P"); |
| IIncludePathEntry entry = JavaScriptCore.newSourceEntry(new Path("/P"), new IPath[0], new IPath[0], null, new IIncludePathAttribute[] {}); |
| project.setRawIncludepath(new IIncludePathEntry[] {entry}, null); |
| String contents = new String (org.eclipse.wst.jsdt.internal.core.util.Util.getResourceContentsAsCharArray(getFile("/P/.settings/.jsdtscope"))); |
| assertSourceEquals( |
| "Unexpected content", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry kind=\"src\" path=\"\"/>\n" + |
| " <classpathentry kind=\"output\" path=\"\"/>\n" + |
| "</classpath>\n", |
| contents); |
| } finally { |
| deleteProject("P"); |
| } |
| } |
| /* |
| * Ensures that setting 1 extra classpath attributes generates the correct .classpath file. |
| */ |
| public void testExtraAttributes2() throws CoreException { |
| try { |
| IJavaScriptProject project = createJavaProject("P"); |
| IIncludePathAttribute attribute = JavaScriptCore.newIncludepathAttribute("foo", "some value"); |
| IIncludePathEntry entry = JavaScriptCore.newSourceEntry(new Path("/P"), new IPath[0], new IPath[0], null, new IIncludePathAttribute[] {attribute}); |
| project.setRawIncludepath(new IIncludePathEntry[] {entry}, null); |
| String contents = new String (org.eclipse.wst.jsdt.internal.core.util.Util.getResourceContentsAsCharArray(getFile("/P/.settings/.jsdtscope"))); |
| assertSourceEquals( |
| "Unexpected content", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry kind=\"src\" path=\"\">\n" + |
| " <attributes>\n" + |
| " <attribute name=\"foo\" value=\"some value\"/>\n" + |
| " </attributes>\n" + |
| " </classpathentry>\n" + |
| " <classpathentry kind=\"output\" path=\"\"/>\n" + |
| "</classpath>\n", |
| contents); |
| } finally { |
| deleteProject("P"); |
| } |
| } |
| /* |
| * Ensures that setting 2 extra classpath attributes generates the correct .classpath file. |
| */ |
| public void testExtraAttributes3() throws CoreException { |
| try { |
| IJavaScriptProject project = createJavaProject("P"); |
| IIncludePathAttribute attribute1 = JavaScriptCore.newIncludepathAttribute("foo", "some value"); |
| IIncludePathAttribute attribute2 = JavaScriptCore.newIncludepathAttribute("bar", "other value"); |
| IIncludePathEntry entry = JavaScriptCore.newSourceEntry(new Path("/P"), new IPath[0], new IPath[0], null, new IIncludePathAttribute[] {attribute1, attribute2}); |
| project.setRawIncludepath(new IIncludePathEntry[] {entry}, null); |
| String contents = new String (org.eclipse.wst.jsdt.internal.core.util.Util.getResourceContentsAsCharArray(getFile("/P/.settings/.jsdtscope"))); |
| assertSourceEquals( |
| "Unexpected content", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry kind=\"src\" path=\"\">\n" + |
| " <attributes>\n" + |
| " <attribute name=\"foo\" value=\"some value\"/>\n" + |
| " <attribute name=\"bar\" value=\"other value\"/>\n" + |
| " </attributes>\n" + |
| " </classpathentry>\n" + |
| " <classpathentry kind=\"output\" path=\"\"/>\n" + |
| "</classpath>\n", |
| contents); |
| } finally { |
| deleteProject("P"); |
| } |
| } |
| /* |
| * Ensures that extra classpath attributes in a .classpath file are correctly read. |
| */ |
| public void testExtraAttributes4() throws CoreException { |
| try { |
| IJavaScriptProject project = createJavaProject("P"); |
| editFile( |
| "/P/.settings/.jsdtscope", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry kind=\"src\" path=\"\">\n" + |
| " <attributes>\n" + |
| " <attribute value=\"some value\" name=\"foo\"/>\n" + |
| " </attributes>\n" + |
| " </classpathentry>\n" + |
| " <classpathentry kind=\"output\" path=\"\"/>\n" + |
| "</classpath>\n" |
| ); |
| assertClasspathEquals( |
| project.getRawIncludepath(), |
| "/P[CPE_SOURCE][K_SOURCE][isExported:false][attributes:foo=some value]" |
| ); |
| } finally { |
| deleteProject("P"); |
| } |
| } |
| /** |
| * Test IJavaScriptProject.hasClasspathCycle(IIncludePathEntry[]). |
| */ |
| public void testHasClasspathCycle() throws CoreException { |
| try { |
| IJavaScriptProject p1 = this.createJavaProject("P1", new String[] {""}); |
| IJavaScriptProject p2 = this.createJavaProject("P2", new String[] {""}); |
| this.createJavaProject("P3", new String[] {""}, new String[] {}, new String[] {"/P1"}); |
| |
| IIncludePathEntry[] originalP1CP= p1.getRawIncludepath(); |
| IIncludePathEntry[] originalP2CP= p2.getRawIncludepath(); |
| |
| // Ensure no cycle reported |
| assertTrue("P1 should not have a cycle", !p1.hasIncludepathCycle(originalP1CP)); |
| |
| // Ensure that adding NervousTest as a prerequesite of P2 doesn't report a cycle |
| int length = originalP2CP.length; |
| IIncludePathEntry[] newCP= new IIncludePathEntry[length + 1]; |
| System.arraycopy(originalP2CP, 0 , newCP, 0, length); |
| newCP[length]= JavaScriptCore.newProjectEntry(p1.getProject().getFullPath(), false); |
| assertTrue("P2 should not have a cycle", !p2.hasIncludepathCycle(newCP)); |
| p2.setRawIncludepath(newCP, null); |
| |
| // Ensure that adding P3 as a prerequesite of P1 reports a cycle |
| length = originalP1CP.length; |
| newCP= new IIncludePathEntry[length + 1]; |
| System.arraycopy(originalP1CP, 0 , newCP, 0, length); |
| newCP[length]= JavaScriptCore.newProjectEntry(p2.getProject().getFullPath(), false); |
| assertTrue("P3 should have a cycle", p2.hasIncludepathCycle(newCP)); |
| |
| // Ensure a cycle is not reported through markers |
| IWorkspace workspace = getJavaModel().getWorkspace(); |
| IMarker[] markers = workspace.getRoot().findMarkers(IJavaScriptModelMarker.TRANSIENT_PROBLEM, true, 1); |
| boolean hasCycleMarker = false; |
| for (int i = 0; i < markers.length; i++){ |
| if (markers[i].getAttribute(IJavaScriptModelMarker.CYCLE_DETECTED) != null) { |
| hasCycleMarker = true; |
| break; |
| } |
| } |
| assertTrue("Should have no cycle markers", !hasCycleMarker); |
| |
| } finally { |
| // cleanup |
| this.deleteProjects(new String[] {"P1", "P2", "P3"}); |
| } |
| } |
| /** |
| * Ensures that a marker is created if editing the .classpath results in an invalid classpath. |
| */ |
| public void testInvalidClasspath1() throws CoreException { |
| try { |
| IJavaScriptProject project = this.createJavaProject("P", new String[] {"src"}); |
| this.editFile( |
| "/P/.settings/.jsdtscope", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry kind=\"src\" path=\"src\"/\n" + // missing closing > |
| " <classpathentry kind=\"output\" path=\"bin\"/>\n" + |
| "</classpath>" |
| ); |
| assertMarkers( |
| "Unexpected markers", |
| "XML format error in \'.classpath\' file of project P: Bad format", |
| project); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| /** |
| * Ensures that a marker is created if editing the .classpath results in an invalid classpath. |
| */ |
| public void testInvalidClasspath2() throws CoreException { |
| try { |
| IJavaScriptProject javaProject = this.createJavaProject("P", new String[] {"src"}); |
| this.editFile( |
| "/P/.settings/.jsdtscope", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry kind=\"src1\" path=\"src\"/>\n" + // invalid kind: src1 |
| " <classpathentry kind=\"output\" path=\"bin\"/>\n" + |
| "</classpath>" |
| ); |
| assertMarkers( |
| "Unexpected markers", |
| "Illegal entry in \'.classpath\' of project P file: Unknown kind: \'src1\'", |
| javaProject); |
| |
| // Verify that error marker is not removed after build |
| // (regression test for bug 42366: Classpath validation error message removed while rebuilding a project.) |
| IProject project = javaProject.getProject(); |
| project.build(IncrementalProjectBuilder.FULL_BUILD, null); |
| waitForAutoBuild(); |
| assertMarkers( |
| "Unexpected markers", |
| "Illegal entry in \'.classpath\' of project P file: Unknown kind: \'src1\'", |
| javaProject); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Ensures that a non existing source folder cannot be put on the classpath. |
| * (regression test for bug 66512 Invalid classpath entry not rejected) |
| */ |
| public void testInvalidSourceFolder() throws CoreException { |
| try { |
| createJavaProject("P1"); |
| IJavaScriptProject proj = createJavaProject("P2", new String[] {}, new String[] {}, new String[] {"/P1/src1/src2"}); |
| assertMarkers( |
| "Unexpected markers", |
| "Project P2 is missing required source folder: \'/P1/src1/src2\'", |
| proj); |
| } finally { |
| deleteProject("P1"); |
| deleteProject("P2"); |
| } |
| } |
| /** |
| * Ensures that only one marker is created if building a project that is |
| * missing its .classpath file multiple times. |
| * (regression test for bug 39877 Rebuild All generates extra "Unable to read classpath" entry.) |
| */ |
| public void testMissingClasspath() throws CoreException { |
| try { |
| IJavaScriptProject javaProject = createJavaProject("P"); |
| IProject project = javaProject.getProject(); |
| project.close(null); |
| deleteFile(new File(project.getLocation().toOSString(), ".settings/.jsdtscope")); |
| waitForAutoBuild(); |
| project.open(null); |
| waitForAutoBuild(); |
| project.build(IncrementalProjectBuilder.FULL_BUILD, null); |
| waitForAutoBuild(); |
| project.build(IncrementalProjectBuilder.FULL_BUILD, null); |
| waitForAutoBuild(); |
| assertMarkers( |
| "Unexpected markers", |
| "Unable to read \'.jsdtscope\' file of project P", |
| javaProject); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| /** |
| * Test that a marker is added when a project as a missing project in its classpath. |
| */ |
| public void testMissingPrereq1() throws CoreException { |
| try { |
| IJavaScriptProject javaProject = this.createJavaProject("A", new String[] {}); |
| IIncludePathEntry[] classpath = |
| new IIncludePathEntry[] { |
| JavaScriptCore.newProjectEntry(new Path("/B")) |
| }; |
| javaProject.setRawIncludepath(classpath, null); |
| this.assertMarkers( |
| "Unexpected markers", |
| "Project A is missing required Java project: \'B\'", |
| javaProject); |
| } finally { |
| this.deleteProject("A"); |
| } |
| } |
| /** |
| * Test that a marker is added when a project as a missing project in its classpath. |
| */ |
| public void testMissingPrereq2() throws CoreException { |
| try { |
| IJavaScriptProject javaProject = |
| this.createJavaProject( |
| "A", |
| new String[] {}, // source folders |
| new String[] {}, // lib folders |
| new String[] {"/B"}); |
| this.assertMarkers( |
| "Unexpected markers", |
| "Project A is missing required Java project: \'B\'", |
| javaProject); |
| } finally { |
| this.deleteProject("A"); |
| } |
| } |
| /** |
| * Test that a marker indicating a missing project is removed when the project is added. |
| */ |
| public void testMissingPrereq3() throws CoreException { |
| try { |
| IJavaScriptProject javaProject = |
| this.createJavaProject( |
| "A", |
| new String[] {}, // source folders |
| new String[] {}, // lib folders |
| new String[] {"/B"}); |
| this.createJavaProject("B", new String[] {}); |
| this.assertMarkers("Unexpected markers", "", javaProject); |
| } finally { |
| this.deleteProjects(new String[] {"A", "B"}); |
| } |
| } |
| /** |
| * Test that a marker indicating a cycle is removed when a project in the cycle is deleted |
| * and replaced with a missing prereq marker. |
| * (regression test for bug 15168 circular errors not reported) |
| */ |
| public void testMissingPrereq4() throws CoreException { |
| try { |
| IJavaScriptProject projectA = |
| this.createJavaProject( |
| "A", |
| new String[] {}, // source folders |
| new String[] {}, // lib folders |
| new String[] {"/B"}); |
| IJavaScriptProject projectB = |
| this.createJavaProject( |
| "B", |
| new String[] {}, // source folders |
| new String[] {}, // lib folders |
| new String[] {"/A"}); |
| this.assertMarkers( |
| "Unexpected markers for project A", |
| "A cycle was detected in the include path of project: A", |
| projectA); |
| this.assertMarkers( |
| "Unexpected markers for project B", |
| "A cycle was detected in the include path of project: B", |
| projectB); |
| |
| // delete project B |
| this.deleteProject("B"); |
| this.assertMarkers( |
| "Unexpected markers for project A after deleting of project B", |
| "Project A is missing required Java project: \'B\'", |
| projectA); |
| |
| // add project B back |
| projectB = |
| this.createJavaProject( |
| "B", |
| new String[] {}, // source folders |
| new String[] {}, // lib folders |
| new String[] {"/A"}); |
| this.assertMarkers( |
| "Unexpected markers for project A after adding project B back", |
| "A cycle was detected in the build path of project: A", |
| projectA); |
| this.assertMarkers( |
| "Unexpected markers for project B after adding project B back", |
| "A cycle was detected in the build path of project: B", |
| projectB); |
| |
| } finally { |
| this.deleteProjects(new String[] {"A", "B"}); |
| } |
| } |
| /** |
| * Setting the classpath to null should be the same as using the |
| * default classpath. |
| */ |
| public void testNullClasspath() throws CoreException { |
| try { |
| IJavaScriptProject project = this.createJavaProject("P", new String[] {""}); |
| setClasspath(project, null); |
| IIncludePathEntry[] cp= project.getRawIncludepath(); |
| assertTrue("classpath should have one root entry", cp.length == 1 && cp[0].getPath().equals(project.getUnderlyingResource().getFullPath())); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Ensures that setting the 'combineAccessRules' flag to false on a project entry generates the correct .classpath file. |
| */ |
| public void testCombineAccessRules1() throws CoreException { |
| try { |
| createJavaProject("P1"); |
| IJavaScriptProject project = createJavaProject("P2"); |
| IIncludePathEntry entry = JavaScriptCore.newProjectEntry(new Path("/P1"), (IAccessRule[]) null, false/*don't combine*/, new IIncludePathAttribute[] {}, false); |
| project.setRawIncludepath(new IIncludePathEntry[] {entry}, null); |
| String contents = new String (org.eclipse.wst.jsdt.internal.core.util.Util.getResourceContentsAsCharArray(getFile("/P2/.settings/.jsdtscope"))); |
| assertSourceEquals( |
| "Unexpected content", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry combineaccessrules=\"false\" kind=\"src\" path=\"/P1\"/>\n" + |
| " <classpathentry kind=\"output\" path=\"\"/>\n" + |
| "</classpath>\n", |
| contents); |
| } finally { |
| deleteProject("P1"); |
| deleteProject("P2"); |
| } |
| } |
| |
| /* |
| * Ensures that setting the 'combineAccessRules' flag to true on a project entry generates the correct .classpath file. |
| */ |
| public void testCombineAccessRules2() throws CoreException { |
| try { |
| createJavaProject("P1"); |
| IJavaScriptProject project = createJavaProject("P2"); |
| IIncludePathEntry entry = JavaScriptCore.newProjectEntry(new Path("/P1"), (IAccessRule[]) null, true/*combine*/, new IIncludePathAttribute[] {}, false); |
| project.setRawIncludepath(new IIncludePathEntry[] {entry}, null); |
| String contents = new String (org.eclipse.wst.jsdt.internal.core.util.Util.getResourceContentsAsCharArray(getFile("/P2/.settings/.jsdtscope"))); |
| assertSourceEquals( |
| "Unexpected content", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry kind=\"src\" path=\"/P1\"/>\n" + |
| " <classpathentry kind=\"output\" path=\"\"/>\n" + |
| "</classpath>\n", |
| contents); |
| } finally { |
| deleteProject("P1"); |
| deleteProject("P2"); |
| } |
| } |
| |
| /* |
| * Ensures that 'combineAccessRules' flag in a .classpath file is correctly read. |
| */ |
| public void testCombineAccessRules3() throws CoreException { |
| try { |
| IJavaScriptProject project = createJavaProject("P2"); |
| editFile( |
| "/P2/.settings/.jsdtscope", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry kind=\"src\" combineaccessrules=\"false\" path=\"/P1\"/>\n" + |
| " <classpathentry kind=\"output\" path=\"\"/>\n" + |
| "</classpath>\n" |
| ); |
| assertClasspathEquals( |
| project.getRawIncludepath(), |
| "/P1[CPE_PROJECT][K_SOURCE][isExported:false][combine access rules:false]" |
| ); |
| } finally { |
| deleteProject("P2"); |
| } |
| } |
| |
| /* |
| * Ensures that the absence of 'combineAccessRules' flag in a .classpath file is correctly handled. |
| */ |
| public void testCombineAccessRules4() throws CoreException { |
| try { |
| IJavaScriptProject project = 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>\n" |
| ); |
| assertClasspathEquals( |
| project.getRawIncludepath(), |
| "/P1[CPE_PROJECT][K_SOURCE][isExported:false][combine access rules:true]" |
| ); |
| } finally { |
| deleteProject("P2"); |
| } |
| } |
| |
| /* |
| * Ensures that the absence of 'combineAccessRules' flag in a .classpath file is correctly handled. |
| */ |
| public void testCombineAccessRules5() throws CoreException { |
| try { |
| IJavaScriptProject project = createJavaProject("P2"); |
| editFile( |
| "/P2/.settings/.jsdtscope", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry kind=\"src\" path=\"src\"/>\n" + |
| " <classpathentry kind=\"output\" path=\"bin\"/>\n" + |
| "</classpath>\n" |
| ); |
| assertClasspathEquals( |
| project.getRawIncludepath(), |
| "/P2/src[CPE_SOURCE][K_SOURCE][isExported:false]" |
| ); |
| } finally { |
| deleteProject("P2"); |
| } |
| } |
| |
| public void testCycleDetection() throws CoreException { |
| |
| int max = 5; |
| IJavaScriptProject[] p = new IJavaScriptProject[max]; |
| String[] projectNames = new String[max]; |
| try { |
| for (int i = 0; i < max; i++) { |
| projectNames[i] = "P"+i; |
| p[i] = this.createJavaProject(projectNames[i], new String[] {""}); |
| } |
| |
| IIncludePathEntry[][] extraEntries = new IIncludePathEntry[][]{ |
| { JavaScriptCore.newProjectEntry(p[1].getPath()), JavaScriptCore.newProjectEntry(p[3].getPath()) }, |
| { JavaScriptCore.newProjectEntry(p[2].getPath()), JavaScriptCore.newProjectEntry(p[3].getPath()) }, |
| { JavaScriptCore.newProjectEntry(p[1].getPath()) }, |
| { JavaScriptCore.newProjectEntry(p[4].getPath())}, |
| { JavaScriptCore.newProjectEntry(p[3].getPath()), JavaScriptCore.newProjectEntry(p[0].getPath()) } |
| }; |
| |
| int[][] expectedCycleParticipants = new int[][] { |
| { 0, 0, 0, 0, 0 }, // after setting CP p[0] |
| { 0, 0, 0, 0, 0 }, // after setting CP p[1] |
| { 0, 1, 1, 0, 0 }, // after setting CP p[2] |
| { 0, 1, 1, 0, 0 }, // after setting CP p[3] |
| { 1, 1, 1, 1, 1 }, // after setting CP p[4] |
| }; |
| |
| for (int i = 0; i < p.length; i++){ |
| |
| // append project references |
| IIncludePathEntry[] oldClasspath = p[i].getRawIncludepath(); |
| IIncludePathEntry[] newClasspath = new IIncludePathEntry[oldClasspath.length+extraEntries[i].length]; |
| System.arraycopy(oldClasspath, 0 , newClasspath, 0, oldClasspath.length); |
| for (int j = 0; j < extraEntries[i].length; j++){ |
| newClasspath[oldClasspath.length+j] = extraEntries[i][j]; |
| } |
| // set classpath |
| p[i].setRawIncludepath(newClasspath, null); |
| |
| // check cycle markers |
| this.assertCycleMarkers(p[i], p, expectedCycleParticipants[i]); |
| } |
| //this.startDeltas(); |
| |
| } finally { |
| this.deleteProjects(projectNames); |
| } |
| } |
| |
| public void testCycleDetectionThroughContainers() throws CoreException { |
| |
| int max = 5; |
| IJavaScriptProject[] p = new IJavaScriptProject[max]; |
| String[] projectNames = new String[max]; |
| try { |
| for (int i = 0; i < max; i++) { |
| projectNames[i] = "P"+i; |
| p[i] = this.createJavaProject(projectNames[i], new String[] {""}); |
| } |
| |
| IJsGlobalScopeContainer[] containers = new IJsGlobalScopeContainer[]{ |
| new TestContainer( |
| new Path("container0/default"), |
| new IIncludePathEntry[]{ JavaScriptCore.newProjectEntry(p[3].getPath()) }), |
| new TestContainer( |
| new Path("container1/default"), |
| new IIncludePathEntry[]{ JavaScriptCore.newProjectEntry(p[1].getPath()) }), |
| new TestContainer( |
| new Path("container2/default"), |
| new IIncludePathEntry[]{ JavaScriptCore.newProjectEntry(p[4].getPath()) }), |
| }; |
| |
| IIncludePathEntry[][] extraEntries = new IIncludePathEntry[][]{ |
| { JavaScriptCore.newProjectEntry(p[1].getPath()), JavaScriptCore.newContainerEntry(containers[0].getPath()) }, |
| { JavaScriptCore.newProjectEntry(p[2].getPath()), JavaScriptCore.newProjectEntry(p[3].getPath()) }, |
| { JavaScriptCore.newContainerEntry(containers[1].getPath()) }, |
| { JavaScriptCore.newContainerEntry(containers[2].getPath())}, |
| { JavaScriptCore.newProjectEntry(p[3].getPath()), JavaScriptCore.newProjectEntry(p[0].getPath()) } |
| }; |
| |
| int[][] expectedCycleParticipants = new int[][] { |
| { 0, 0, 0, 0, 0 }, // after setting CP p[0] |
| { 0, 0, 0, 0, 0 }, // after setting CP p[1] |
| { 0, 0, 0, 0, 0 }, // after setting CP p[2] |
| { 0, 0, 0, 0, 0 }, // after setting CP p[3] |
| { 1, 1, 1, 1, 1 }, // after setting CP p[4] |
| }; |
| |
| for (int i = 0; i < p.length; i++){ |
| |
| // append project references |
| IIncludePathEntry[] oldClasspath = p[i].getRawIncludepath(); |
| IIncludePathEntry[] newClasspath = new IIncludePathEntry[oldClasspath.length+extraEntries[i].length]; |
| System.arraycopy(oldClasspath, 0 , newClasspath, 0, oldClasspath.length); |
| for (int j = 0; j < extraEntries[i].length; j++){ |
| newClasspath[oldClasspath.length+j] = extraEntries[i][j]; |
| } |
| // set classpath |
| p[i].setRawIncludepath(newClasspath, null); |
| |
| // update container paths |
| if (i == p.length - 1){ |
| JavaScriptCore.setJsGlobalScopeContainer( |
| containers[0].getPath(), |
| new IJavaScriptProject[]{ p[0] }, |
| new IJsGlobalScopeContainer[] { containers[0] }, |
| null); |
| |
| JavaScriptCore.setJsGlobalScopeContainer( |
| containers[1].getPath(), |
| new IJavaScriptProject[]{ p[2] }, |
| new IJsGlobalScopeContainer[] { containers[1] }, |
| null); |
| |
| JavaScriptCore.setJsGlobalScopeContainer( |
| containers[2].getPath(), |
| new IJavaScriptProject[]{ p[3] }, |
| new IJsGlobalScopeContainer[] { containers[2] }, |
| null); |
| } |
| |
| // check cycle markers |
| this.assertCycleMarkers(p[i], p, expectedCycleParticipants[i]); |
| } |
| //this.startDeltas(); |
| |
| } finally { |
| //this.stopDeltas(); |
| this.deleteProjects(projectNames); |
| } |
| } |
| public void testCycleDetectionThroughContainerVariants() throws CoreException { |
| |
| int max = 5; |
| IJavaScriptProject[] p = new IJavaScriptProject[max]; |
| String[] projectNames = new String[max]; |
| try { |
| for (int i = 0; i < max; i++) { |
| projectNames[i] = "P"+i; |
| p[i] = this.createJavaProject(projectNames[i], new String[] {""}); |
| } |
| |
| class LocalTestContainer implements IJsGlobalScopeContainer { |
| IPath path; |
| IIncludePathEntry[] entries; |
| LocalTestContainer(IPath path, IIncludePathEntry[] entries){ |
| this.path = path; |
| this.entries = entries; |
| } |
| public IPath getPath() { return this.path; } |
| /** |
| * @deprecated Use {@link #getIncludepathEntries()} instead |
| */ |
| public IIncludePathEntry[] getClasspathEntries() { |
| return getIncludepathEntries(); |
| } |
| public IIncludePathEntry[] getIncludepathEntries() { return this.entries; } |
| public String getDescription() { return null; } |
| public int getKind() { return 0; } |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.jsdt.core.IJsGlobalScopeContainer#resolvedLibraryImport(java.lang.String) |
| */ |
| public String[] resolvedLibraryImport(String a) { |
| return new String[] {a}; |
| } |
| } |
| |
| IJsGlobalScopeContainer[] containers = new IJsGlobalScopeContainer[]{ |
| new LocalTestContainer( |
| new Path("container0/default"), |
| new IIncludePathEntry[]{ JavaScriptCore.newProjectEntry(p[3].getPath()) }), |
| new LocalTestContainer( |
| new Path("container0/default"), |
| new IIncludePathEntry[]{ JavaScriptCore.newProjectEntry(p[1].getPath()) }), |
| new LocalTestContainer( |
| new Path("container0/default"), |
| new IIncludePathEntry[]{ JavaScriptCore.newProjectEntry(p[4].getPath()) }), |
| }; |
| |
| IIncludePathEntry[][] extraEntries = new IIncludePathEntry[][]{ |
| { JavaScriptCore.newProjectEntry(p[1].getPath()), JavaScriptCore.newContainerEntry(containers[0].getPath()) }, |
| { JavaScriptCore.newProjectEntry(p[2].getPath()), JavaScriptCore.newProjectEntry(p[3].getPath()) }, |
| { JavaScriptCore.newContainerEntry(containers[1].getPath()) }, |
| { JavaScriptCore.newContainerEntry(containers[2].getPath())}, |
| { JavaScriptCore.newProjectEntry(p[3].getPath()), JavaScriptCore.newProjectEntry(p[0].getPath()) } |
| }; |
| |
| int[][] expectedCycleParticipants = new int[][] { |
| { 0, 0, 0, 0, 0 }, // after setting CP p[0] |
| { 0, 0, 0, 0, 0 }, // after setting CP p[1] |
| { 0, 0, 0, 0, 0 }, // after setting CP p[2] |
| { 0, 0, 0, 0, 0 }, // after setting CP p[3] |
| { 1, 1, 1, 1, 1 }, // after setting CP p[4] |
| }; |
| |
| for (int i = 0; i < p.length; i++){ |
| |
| // append project references |
| IIncludePathEntry[] oldClasspath = p[i].getRawIncludepath(); |
| IIncludePathEntry[] newClasspath = new IIncludePathEntry[oldClasspath.length+extraEntries[i].length]; |
| System.arraycopy(oldClasspath, 0 , newClasspath, 0, oldClasspath.length); |
| for (int j = 0; j < extraEntries[i].length; j++){ |
| newClasspath[oldClasspath.length+j] = extraEntries[i][j]; |
| } |
| // set classpath |
| p[i].setRawIncludepath(newClasspath, null); |
| |
| // update same container path for multiple projects |
| if (i == p.length - 1){ |
| JavaScriptCore.setJsGlobalScopeContainer( |
| containers[0].getPath(), |
| new IJavaScriptProject[]{ p[0], p[2], p[3] }, |
| new IJsGlobalScopeContainer[] { containers[0], containers[1], containers[2] }, |
| null); |
| } |
| |
| // check cycle markers |
| this.assertCycleMarkers(p[i], p, expectedCycleParticipants[i]); |
| } |
| //this.startDeltas(); |
| |
| } finally { |
| //this.stopDeltas(); |
| this.deleteProjects(projectNames); |
| } |
| } |
| public void testCycleDetection2() throws CoreException { |
| |
| int max = 5; |
| IJavaScriptProject[] p = new IJavaScriptProject[max]; |
| String[] projectNames = new String[max]; |
| try { |
| for (int i = 0; i < max; i++) { |
| projectNames[i] = "P"+i; |
| p[i] = this.createJavaProject(projectNames[i], new String[] {""}); |
| } |
| |
| IIncludePathEntry[][] extraEntries = new IIncludePathEntry[][]{ |
| { JavaScriptCore.newProjectEntry(p[1].getPath()), JavaScriptCore.newProjectEntry(p[3].getPath()) }, |
| { JavaScriptCore.newProjectEntry(p[2].getPath()) }, |
| { JavaScriptCore.newProjectEntry(p[0].getPath()) }, |
| { JavaScriptCore.newProjectEntry(p[4].getPath())}, |
| { JavaScriptCore.newProjectEntry(p[0].getPath()) } |
| }; |
| |
| int[][] expectedCycleParticipants = new int[][] { |
| { 0, 0, 0, 0, 0 }, // after setting CP p[0] |
| { 0, 0, 0, 0, 0 }, // after setting CP p[1] |
| { 1, 1, 1, 0, 0 }, // after setting CP p[2] |
| { 1, 1, 1, 0, 0 }, // after setting CP p[3] |
| { 1, 1, 1, 1, 1 }, // after setting CP p[4] |
| }; |
| |
| for (int i = 0; i < p.length; i++){ |
| |
| // append project references |
| IIncludePathEntry[] oldClasspath = p[i].getRawIncludepath(); |
| IIncludePathEntry[] newClasspath = new IIncludePathEntry[oldClasspath.length+extraEntries[i].length]; |
| System.arraycopy(oldClasspath, 0 , newClasspath, 0, oldClasspath.length); |
| for (int j = 0; j < extraEntries[i].length; j++){ |
| newClasspath[oldClasspath.length+j] = extraEntries[i][j]; |
| } |
| // set classpath |
| p[i].setRawIncludepath(newClasspath, null); |
| |
| // check cycle markers |
| this.assertCycleMarkers(p[i], p, expectedCycleParticipants[i]); |
| } |
| //this.startDeltas(); |
| |
| } finally { |
| //this.stopDeltas(); |
| this.deleteProjects(projectNames); |
| } |
| } |
| |
| public void testCycleDetection3() throws CoreException { |
| |
| int max = 6; |
| IJavaScriptProject[] p = new IJavaScriptProject[max]; |
| String[] projectNames = new String[max]; |
| try { |
| for (int i = 0; i < max; i++) { |
| projectNames[i] = "P"+i; |
| p[i] = this.createJavaProject(projectNames[i], new String[] {""}); |
| } |
| |
| IIncludePathEntry[][] extraEntries = new IIncludePathEntry[][]{ |
| { JavaScriptCore.newProjectEntry(p[2].getPath()), JavaScriptCore.newProjectEntry(p[4].getPath()) }, |
| { JavaScriptCore.newProjectEntry(p[0].getPath()) }, |
| { JavaScriptCore.newProjectEntry(p[3].getPath()) }, |
| { JavaScriptCore.newProjectEntry(p[1].getPath())}, |
| { JavaScriptCore.newProjectEntry(p[5].getPath()) }, |
| { JavaScriptCore.newProjectEntry(p[1].getPath()) } |
| }; |
| |
| int[][] expectedCycleParticipants = new int[][] { |
| { 0, 0, 0, 0, 0, 0 }, // after setting CP p[0] |
| { 0, 0, 0, 0, 0, 0 }, // after setting CP p[1] |
| { 0, 0, 0, 0, 0, 0 }, // after setting CP p[2] |
| { 1, 1, 1, 1, 0, 0 }, // after setting CP p[3] |
| { 1, 1, 1, 1, 0, 0 }, // after setting CP p[4] |
| { 1, 1, 1, 1, 1 , 1}, // after setting CP p[5] |
| }; |
| |
| for (int i = 0; i < p.length; i++){ |
| |
| // append project references |
| IIncludePathEntry[] oldClasspath = p[i].getRawIncludepath(); |
| IIncludePathEntry[] newClasspath = new IIncludePathEntry[oldClasspath.length+extraEntries[i].length]; |
| System.arraycopy(oldClasspath, 0 , newClasspath, 0, oldClasspath.length); |
| for (int j = 0; j < extraEntries[i].length; j++){ |
| newClasspath[oldClasspath.length+j] = extraEntries[i][j]; |
| } |
| // set classpath |
| p[i].setRawIncludepath(newClasspath, null); |
| |
| // check cycle markers |
| this.assertCycleMarkers(p[i], p, expectedCycleParticipants[i]); |
| } |
| //this.startDeltas(); |
| |
| } finally { |
| //this.stopDeltas(); |
| this.deleteProjects(projectNames); |
| } |
| } |
| /* |
| * Ensures that a cycle is detected if introduced during a post-change event. |
| * (regression test for bug 113051 No classpath marker produced when cycle through PDE container) |
| */ |
| public void testCycleDetection4() throws CoreException { |
| IResourceChangeListener listener = new IResourceChangeListener() { |
| boolean containerNeedUpdate = true; |
| public void resourceChanged(IResourceChangeEvent event) { |
| if (containerNeedUpdate) { |
| TestContainer container = new TestContainer( |
| new Path("org.eclipse.wst.jsdt.core.tests.model.container/default"), |
| new IIncludePathEntry[] { JavaScriptCore.newProjectEntry(new Path("/P1")) }); |
| try { |
| JavaScriptCore.setJsGlobalScopeContainer(container.getPath(), new IJavaScriptProject[] {getJavaProject("P2")}, new IJsGlobalScopeContainer[] {container}, null); |
| } catch (JavaScriptModelException e) { |
| e.printStackTrace(); |
| } |
| containerNeedUpdate = false; |
| } |
| } |
| }; |
| try { |
| IJavaScriptProject p1 = createJavaProject("P1", new String[] {}, new String[] {}, new String[] {"/P2"}); |
| TestContainer container = new TestContainer( |
| new Path("org.eclipse.wst.jsdt.core.tests.model.container/default"), |
| new IIncludePathEntry[] {}); |
| IJavaScriptProject p2 = createJavaProject("P2", new String[] {}, new String[] {container.getPath().toString()}); |
| JavaScriptCore.setJsGlobalScopeContainer(container.getPath(), new IJavaScriptProject[] {p2}, new IJsGlobalScopeContainer[] {container}, null); |
| waitForAutoBuild(); |
| getWorkspace().addResourceChangeListener(listener, IResourceChangeEvent.POST_CHANGE); |
| createFile("/P1/test.txt", ""); |
| assertCycleMarkers(p1, new IJavaScriptProject[] {p1, p2}, new int[] {1, 1}); |
| } finally { |
| getWorkspace().removeResourceChangeListener(listener); |
| deleteProjects(new String[] {"P1", "P2"}); |
| } |
| } |
| public void testPerfDenseCycleDetection1() throws CoreException { |
| // each project prereqs all other projects |
| denseCycleDetection(5); |
| } |
| public void testPerfDenseCycleDetection2() throws CoreException { |
| // each project prereqs all other projects |
| denseCycleDetection(10); |
| } |
| public void testPerfDenseCycleDetection3() throws CoreException { |
| // each project prereqs all other projects |
| denseCycleDetection(20); |
| } |
| /* |
| * Create projects and set classpaths in one batch |
| */ |
| public void testNoCycleDetection1() throws CoreException { |
| |
| // each project prereqs all the previous ones |
| noCycleDetection(5, false, false); |
| noCycleDetection(10, false, false); |
| noCycleDetection(20, false, false); |
| |
| // each project prereqs all the next ones |
| noCycleDetection(5, true, false); |
| noCycleDetection(10, true, false); |
| noCycleDetection(20, true, false); |
| } |
| /* |
| * Create projects first, then set classpaths |
| */ |
| public void testNoCycleDetection2() throws CoreException { |
| |
| // each project prereqs all the previous ones |
| noCycleDetection(5, false, true); |
| noCycleDetection(10, false, true); |
| noCycleDetection(20, false, true); |
| |
| // each project prereqs all the next ones |
| noCycleDetection(5, true, true); |
| noCycleDetection(10, true, true); |
| noCycleDetection(20, true, true); |
| } |
| /* |
| * Ensures that the .classpath file is not written to disk when setting the raw classpath with no resource change. |
| */ |
| public void testNoResourceChange01() throws CoreException { |
| try { |
| IJavaScriptProject project = createJavaProject("P", new String[] {"src1"}); |
| IIncludePathEntry[] newClasspath = createClasspath("P", new String[] {"/P/src2", ""}); |
| project.setRawIncludepath(newClasspath, false/*cannot modify resources*/, null/*no progress*/); |
| String contents = new String (org.eclipse.wst.jsdt.internal.core.util.Util.getResourceContentsAsCharArray(getFile("/P/.settings/.jsdtscope"))); |
| assertSourceEquals( |
| "Unexpected content", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry kind=\"src\" path=\"src1\"/>\n" + |
| " <classpathentry kind=\"con\" path=\"org.eclipse.wst.jsdt.launching.JRE_CONTAINER\"/>\n" + |
| " <classpathentry kind=\"output\" path=\"\"/>\n" + |
| "</classpath>\n", |
| contents); |
| } finally { |
| deleteProject("P"); |
| } |
| } |
| /* |
| * Ensures that the in-memory classpath is correct when setting the raw classpath with no resource change. |
| */ |
| public void testNoResourceChange02() throws CoreException { |
| try { |
| IJavaScriptProject project = createJavaProject("P", new String[] {"src1"}); |
| IIncludePathEntry[] newClasspath = createClasspath("P", new String[] {"/P/src2", ""}); |
| project.setRawIncludepath(newClasspath, false/*cannot modify resources*/, null/*no progress*/); |
| assertClasspathEquals( |
| project.getRawIncludepath(), |
| "/P/src2[CPE_SOURCE][K_SOURCE][isExported:false]" |
| ); |
| } finally { |
| deleteProject("P"); |
| } |
| } |
| /* |
| * Ensures that a compilation unit on the old classpath doesn't exist after setting a new raw classpath with no resource change. |
| */ |
| public void testNoResourceChange03() throws CoreException { |
| try { |
| IJavaScriptProject project = createJavaProject("P", new String[] {"src1"}); |
| createFile( |
| "/P/src1/X.js", |
| "public class X {\n" + |
| "}" |
| ); |
| IJavaScriptUnit cu = getCompilationUnit("/P/src1/X.js"); |
| cu.open(null); |
| IIncludePathEntry[] newClasspath = createClasspath("P", new String[] {"/P/src2", ""}); |
| project.setRawIncludepath(newClasspath, false/*cannot modify resources*/, null/*no progress*/); |
| assertFalse("Compilation unit should not exist", cu.exists()); |
| } finally { |
| deleteProject("P"); |
| } |
| } |
| /* |
| * Ensures that the delta is correct when setting a new raw classpath with no resource change. |
| */ |
| public void testNoResourceChange04() throws CoreException { |
| try { |
| IJavaScriptProject project = createJavaProject("P", new String[] {"src1"}); |
| createFolder("/P/src2"); |
| IIncludePathEntry[] newClasspath = createClasspath("P", new String[] {"/P/src2", ""}); |
| startDeltas(); |
| project.setRawIncludepath(newClasspath, false/*cannot modify resources*/, null/*no progress*/); |
| assertDeltas( |
| "Unexpected delta", |
| "P[*]: {CHILDREN | CLASSPATH CHANGED}\n" + |
| " src1[*]: {REMOVED FROM CLASSPATH}\n" + |
| " src2[*]: {ADDED TO CLASSPATH}" |
| ); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| /* |
| * Ensures that the in-memory output is correct when setting the output with no resource change. |
| */ |
| public void testNoResourceChange05() throws CoreException { |
| try { |
| IJavaScriptProject project = createJavaProject("P", new String[] {"src1"}); |
| project.setRawIncludepath(project.getRawIncludepath(), false/*cannot modify resources*/, null/*no progress*/); |
| IIncludePathEntry[] entries = project.readRawIncludepath(); // force to read classpath |
| assertEquals( |
| "/P/src2", |
| entries[0].getPath().toString()); |
| } finally { |
| deleteProject("P"); |
| } |
| } |
| /** |
| * Ensures that a duplicate entry created by editing the .classpath is detected. |
| * (regression test for bug 24498 Duplicate entries on classpath cause CP marker to no longer refresh) |
| */ |
| public void testDuplicateEntries() throws CoreException { |
| try { |
| IJavaScriptProject project = this.createJavaProject("P", new String[] {"src"}); |
| this.editFile( |
| "/P/.settings/.jsdtscope", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry kind=\"src\" path=\"src\"/>\n" + |
| " <classpathentry kind=\"src\" path=\"src\"/>\n" + |
| " <classpathentry kind=\"output\" path=\"bin\"/>\n" + |
| "</classpath>" |
| ); |
| assertMarkers( |
| "Unexpected markers", |
| "Build path contains duplicate entry: \'src\' for project P", |
| project); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| private void denseCycleDetection(final int numberOfParticipants) throws CoreException { |
| |
| final IJavaScriptProject[] projects = new IJavaScriptProject[numberOfParticipants]; |
| final String[] projectNames = new String[numberOfParticipants]; |
| final int[] allProjectsInCycle = new int[numberOfParticipants]; |
| |
| try { |
| JavaScriptCore.run(new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| for (int i = 0; i < numberOfParticipants; i++){ |
| projectNames[i] = "P"+i; |
| projects[i] = createJavaProject(projectNames[i], new String[]{""}); |
| allProjectsInCycle[i] = 1; |
| } |
| for (int i = 0; i < numberOfParticipants; i++){ |
| IIncludePathEntry[] extraEntries = new IIncludePathEntry[numberOfParticipants-1]; |
| int index = 0; |
| for (int j = 0; j < numberOfParticipants; j++){ |
| if (i == j) continue; |
| extraEntries[index++] = JavaScriptCore.newProjectEntry(projects[j].getPath()); |
| } |
| // append project references |
| IIncludePathEntry[] oldClasspath = projects[i].getRawIncludepath(); |
| IIncludePathEntry[] newClasspath = new IIncludePathEntry[oldClasspath.length+extraEntries.length]; |
| System.arraycopy(oldClasspath, 0 , newClasspath, 0, oldClasspath.length); |
| for (int j = 0; j < extraEntries.length; j++){ |
| newClasspath[oldClasspath.length+j] = extraEntries[j]; |
| } |
| // set classpath |
| projects[i].setRawIncludepath(newClasspath, null); |
| } |
| } |
| }, |
| null); |
| |
| for (int i = 0; i < numberOfParticipants; i++){ |
| // check cycle markers |
| this.assertCycleMarkers(projects[i], projects, allProjectsInCycle); |
| } |
| |
| } finally { |
| this.deleteProjects(projectNames); |
| } |
| } |
| /* |
| * When using forward references, all projects prereq all of the ones which have a greater index, |
| * e.g. P0, P1, P2: P0 prereqs {P1, P2}, P1 prereqs {P2}, P2 prereqs {} |
| * When no using forward references (i.e. backward refs), all projects prereq projects with smaller index |
| * e.g. P0, P1, P2: P0 prereqs {}, P1 prereqs {P0}, P2 prereqs {P0, P1} |
| */ |
| private void noCycleDetection(final int numberOfParticipants, final boolean useForwardReferences, final boolean createProjectsFirst) throws CoreException { |
| |
| final IJavaScriptProject[] projects = new IJavaScriptProject[numberOfParticipants]; |
| final String[] projectNames = new String[numberOfParticipants]; |
| final int[] allProjectsInCycle = new int[numberOfParticipants]; |
| |
| final long[] start = new long[1]; |
| final long[] time = new long[1]; |
| |
| try { |
| if (createProjectsFirst) { |
| JavaScriptCore.run(new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| for (int i = 0; i < numberOfParticipants; i++){ |
| projectNames[i] = "P"+i; |
| projects[i] = createJavaProject(projectNames[i], new String[]{""}); |
| allProjectsInCycle[i] = 0; |
| } |
| } |
| }, |
| null); |
| } |
| JavaScriptCore.run(new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| if (!createProjectsFirst) { |
| for (int i = 0; i < numberOfParticipants; i++){ |
| projectNames[i] = "P"+i; |
| projects[i] = createJavaProject(projectNames[i], new String[]{""}); |
| allProjectsInCycle[i] = 0; |
| } |
| } |
| for (int i = 0; i < numberOfParticipants; i++){ |
| IIncludePathEntry[] extraEntries = new IIncludePathEntry[useForwardReferences ? numberOfParticipants - i -1 : i]; |
| int index = 0; |
| for (int j = useForwardReferences ? i+1 : 0; |
| useForwardReferences ? (j < numberOfParticipants) : (j < i); |
| j++){ |
| extraEntries[index++] = JavaScriptCore.newProjectEntry(projects[j].getPath()); |
| } |
| // append project references |
| IIncludePathEntry[] oldClasspath = projects[i].getRawIncludepath(); |
| IIncludePathEntry[] newClasspath = new IIncludePathEntry[oldClasspath.length+extraEntries.length]; |
| System.arraycopy(oldClasspath, 0 , newClasspath, 0, oldClasspath.length); |
| for (int j = 0; j < extraEntries.length; j++){ |
| newClasspath[oldClasspath.length+j] = extraEntries[j]; |
| } |
| // set classpath |
| long innerStart = System.currentTimeMillis(); // time spent in individual CP setting |
| projects[i].setRawIncludepath(newClasspath, null); |
| time[0] += System.currentTimeMillis() - innerStart; |
| } |
| start[0] = System.currentTimeMillis(); // time spent in delta refresh |
| } |
| }, |
| null); |
| time[0] += System.currentTimeMillis()-start[0]; |
| //System.out.println("No cycle check ("+numberOfParticipants+" participants) : "+ time[0]+" ms, "+ (useForwardReferences ? "forward references" : "backward references") + ", " + (createProjectsFirst ? "two steps (projects created first, then classpaths are set)" : "one step (projects created and classpaths set in one batch)")); |
| |
| for (int i = 0; i < numberOfParticipants; i++){ |
| // check cycle markers |
| this.assertCycleMarkers(projects[i], projects, allProjectsInCycle); |
| } |
| |
| } finally { |
| this.deleteProjects(projectNames); |
| } |
| } |
| |
| /* |
| * test for bug 32690 |
| * simulate checkout of project with invalid classpath |
| */ |
| public void testNestedSourceFolders() throws CoreException, IOException { |
| try { |
| // create project using Platform/Resources API |
| final IProject project = getProject("P"); |
| IWorkspaceRunnable create = new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| project.create(null, null); |
| project.open(null); |
| } |
| }; |
| getWorkspace().run(create, null); |
| |
| // create folders src and src/src2 using java.io API |
| File pro = project.getLocation().toFile(); |
| File src = createFolder(pro, "src"); |
| createFolder(src, "src2"); |
| |
| // create .project using java.io API |
| createFile(pro, ".project", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<projectDescription>\n" + |
| " <name>org.eclipse.wst.jsdt.core</name>\n" + |
| " <comment></comment>\n" + |
| " <projects>\n" + |
| " </projects>\n" + |
| " <buildSpec>\n" + |
| " <buildCommand>\n" + |
| " <name>org.eclipse.wst.jsdt.core.javabuilder</name>\n" + |
| " <arguments>\n" + |
| " </arguments>\n" + |
| " </buildCommand>\n" + |
| " </buildSpec>\n" + |
| " <natures>\n" + |
| " <nature>org.eclipse.wst.jsdt.core.javanature</nature>\n" + |
| " </natures>\n" + |
| "</projectDescription>"); |
| |
| // create .classpath using java.io API |
| createFile(pro, ".classpath", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry kind=\"src\" path=\"src\"/>\n" + |
| " <classpathentry kind=\"src\" path=\"src/src2\"/>\n" + |
| " <classpathentry kind=\"output\" path=\"bin\"/>\n" + |
| "</classpath>" |
| ); |
| |
| // refresh |
| project.refreshLocal(IResource.DEPTH_INFINITE, null); |
| |
| assertMarkers( |
| "Unexpected markers", |
| "Cannot nest \'P/src/src2\' inside \'P/src\'. To enable the nesting exclude \'src2/\' from \'P/src\'", |
| JavaScriptCore.create(project)); |
| } finally { |
| deleteProject("P"); |
| } |
| } |
| /* |
| * Ensures that no problems are reported for an optional source entry with no corresponding folder. |
| */ |
| public void testOptionalEntry1() throws CoreException { |
| try { |
| IJavaScriptProject javaProject = this.createJavaProject("A", new String[] {}); |
| IIncludePathAttribute attribute = JavaScriptCore.newIncludepathAttribute(IIncludePathAttribute.OPTIONAL, "true"); |
| IIncludePathEntry[] classpath = |
| new IIncludePathEntry[] { |
| JavaScriptCore.newSourceEntry(new Path("/A/src"), new IPath[0], new IPath[0], new Path("/A/bin"), new IIncludePathAttribute[] {attribute}) |
| }; |
| javaProject.setRawIncludepath(classpath, null); |
| assertMarkers( |
| "Unexpected markers", |
| "", |
| javaProject); |
| } finally { |
| this.deleteProject("A"); |
| } |
| } |
| /* |
| * Ensures that no problems are reported for an optional libary entry with no corresponding folder. |
| */ |
| public void testOptionalEntry2() throws CoreException { |
| try { |
| IJavaScriptProject javaProject = this.createJavaProject("A", new String[] {}); |
| IIncludePathAttribute attribute = JavaScriptCore.newIncludepathAttribute(IIncludePathAttribute.OPTIONAL, "true"); |
| IIncludePathEntry[] classpath = |
| new IIncludePathEntry[] { |
| JavaScriptCore.newLibraryEntry(new Path("/A/lib"), null, null, null, new IIncludePathAttribute[] {attribute}, false) |
| }; |
| javaProject.setRawIncludepath(classpath, null); |
| assertMarkers( |
| "Unexpected markers", |
| "", |
| javaProject); |
| } finally { |
| this.deleteProject("A"); |
| } |
| } |
| /* |
| * Ensures that no problems are reported for an optional project entry with no corresponding project. |
| */ |
| public void testOptionalEntry3() throws CoreException { |
| try { |
| IJavaScriptProject javaProject = this.createJavaProject("A", new String[] {}); |
| IIncludePathAttribute attribute = JavaScriptCore.newIncludepathAttribute(IIncludePathAttribute.OPTIONAL, "true"); |
| IIncludePathEntry[] classpath = |
| new IIncludePathEntry[] { |
| JavaScriptCore.newProjectEntry(new Path("/B"), null/*no access rules*/, false/*don't combine access rule*/, new IIncludePathAttribute[] {attribute}, false/*not exported*/) |
| }; |
| javaProject.setRawIncludepath(classpath, null); |
| assertMarkers( |
| "Unexpected markers", |
| "", |
| javaProject); |
| } finally { |
| this.deleteProject("A"); |
| } |
| } |
| |
| /** |
| * Ensure classpath is refreshed when project is replaced (43670) |
| */ |
| public void testReplaceProject() throws CoreException { |
| try { |
| final IJavaScriptProject javaProject = createJavaProject("P", new String[] {"src"}); |
| |
| ResourcesPlugin.getWorkspace().run( |
| new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| IProjectDescription descr = javaProject.getProject().getDescription(); |
| descr.setComment("dummy"); // ensure it is changed |
| javaProject.getProject().setDescription(descr, monitor); |
| editFile( |
| "/P/.settings/.jsdtscope", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry kind=\"src\" path=\"src2\"/>\n" + |
| "</classpath>" |
| ); |
| } |
| }, |
| null); |
| IIncludePathEntry[] classpath = javaProject.getRawIncludepath(); |
| assertEquals("classpath should have been refreshed", new Path("/P/src2"), classpath[0].getPath()); |
| } finally { |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Ensures that unknown classpath attributes in a .classpath file are not lost when read and rewritten. |
| * (regression test for bug 101425 Classpath persistence should be resilient with unknown attributes) |
| */ |
| public void testUnknownAttributes() throws CoreException { |
| try { |
| IJavaScriptProject project = createJavaProject("P"); |
| editFile( |
| "/P/.settings/.jsdtscope", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry unknown=\"test\" kind=\"src\" path=\"src1\"/>\n" + |
| " <classpathentry kind=\"src\" path=\"src2\"/>\n" + |
| " <classpathentry kind=\"output\" path=\"bin\"/>\n" + |
| "</classpath>\n" |
| ); |
| IIncludePathEntry[] classpath = project.getRawIncludepath(); |
| |
| // swap 2 entries |
| IIncludePathEntry src1 = classpath[0]; |
| classpath[0] = classpath[1]; |
| classpath[1] = src1; |
| project.setRawIncludepath(classpath, null); |
| |
| // check that .classpath has correct content |
| String contents = new String (org.eclipse.wst.jsdt.internal.core.util.Util.getResourceContentsAsCharArray(getFile("/P/.settings/.jsdtscope"))); |
| assertSourceEquals( |
| "Unexpected content", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry kind=\"src\" path=\"src2\"/>\n" + |
| " <classpathentry kind=\"src\" path=\"src1\" unknown=\"test\"/>\n" + |
| " <classpathentry kind=\"output\" path=\"bin\"/>\n" + |
| "</classpath>\n", |
| contents); |
| } finally { |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Ensures that unknown classpath elements in a .classpath file are not lost when read and rewritten. |
| * (regression test for bug 101425 Classpath persistence should be resilient with unknown attributes) |
| */ |
| public void testUnknownElements1() throws CoreException { |
| try { |
| IJavaScriptProject project = createJavaProject("P"); |
| editFile( |
| "/P/.settings/.jsdtscope", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry kind=\"src\" path=\"src1\">\n" + |
| " <unknown>\n" + |
| " <test kind=\"\"/>\n" + |
| " </unknown>\n" + |
| " </classpathentry>\n" + |
| " <classpathentry kind=\"src\" path=\"src2\"/>\n" + |
| " <classpathentry kind=\"output\" path=\"bin\"/>\n" + |
| "</classpath>\n" |
| ); |
| IIncludePathEntry[] classpath = project.getRawIncludepath(); |
| |
| // swap 2 entries |
| IIncludePathEntry src1 = classpath[0]; |
| classpath[0] = classpath[1]; |
| classpath[1] = src1; |
| project.setRawIncludepath(classpath, null); |
| |
| // check that .classpath has correct content |
| String contents = new String (org.eclipse.wst.jsdt.internal.core.util.Util.getResourceContentsAsCharArray(getFile("/P/.settings/.jsdtscope"))); |
| assertSourceEquals( |
| "Unexpected content", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry kind=\"src\" path=\"src2\"/>\n" + |
| " <classpathentry kind=\"src\" path=\"src1\">\n" + |
| " <unknown>\n" + |
| " <test kind=\"\"/>\n" + |
| " </unknown>\n" + |
| " </classpathentry>\n" + |
| " <classpathentry kind=\"output\" path=\"bin\"/>\n" + |
| "</classpath>\n", |
| contents); |
| } finally { |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Ensures that unknown classpath elements in a .classpath file are not lost when read and rewritten. |
| * (regression test for bug 101425 Classpath persistence should be resilient with unknown attributes) |
| */ |
| public void testUnknownElements2() throws CoreException { |
| try { |
| IJavaScriptProject project = createJavaProject("P"); |
| editFile( |
| "/P/.settings/.jsdtscope", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry kind=\"src\" unknownattribute=\"abcde\" path=\"src1\">\n" + |
| " <unknown1>\n" + |
| " <test kind=\"1\"/>\n" + |
| " <test kind=\"2\"/>\n" + |
| " </unknown1>\n" + |
| " <unknown2 attribute2=\"\">\n" + |
| " <test>\n" + |
| " <other a=\"b\"/>\n" + |
| " </test>\n" + |
| " </unknown2>\n" + |
| " </classpathentry>\n" + |
| " <classpathentry kind=\"src\" path=\"src2\"/>\n" + |
| " <classpathentry kind=\"output\" path=\"bin\"/>\n" + |
| "</classpath>\n" |
| ); |
| IIncludePathEntry[] classpath = project.getRawIncludepath(); |
| |
| // swap 2 entries |
| IIncludePathEntry src1 = classpath[0]; |
| classpath[0] = classpath[1]; |
| classpath[1] = src1; |
| project.setRawIncludepath(classpath, null); |
| |
| // check that .classpath has correct content |
| String contents = new String (org.eclipse.wst.jsdt.internal.core.util.Util.getResourceContentsAsCharArray(getFile("/P/.settings/.jsdtscope"))); |
| assertSourceEquals( |
| "Unexpected content", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry kind=\"src\" path=\"src2\"/>\n" + |
| " <classpathentry kind=\"src\" path=\"src1\" unknownattribute=\"abcde\">\n" + |
| " <unknown1>\n" + |
| " <test kind=\"1\"/>\n" + |
| " <test kind=\"2\"/>\n" + |
| " </unknown1>\n" + |
| " <unknown2 attribute2=\"\">\n" + |
| " <test>\n" + |
| " <other a=\"b\"/>\n" + |
| " </test>\n" + |
| " </unknown2>\n" + |
| " </classpathentry>\n" + |
| " <classpathentry kind=\"output\" path=\"bin\"/>\n" + |
| "</classpath>\n", |
| contents); |
| } finally { |
| deleteProject("P"); |
| } |
| } |
| |
| /** |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=55992 |
| * Check that Assert.AssertionFailedException exception is well catched |
| * a) when verifying a classpath entry |
| * b) when verifying whole classpath |
| */ |
| public void testBug55992a() throws CoreException { |
| try { |
| IJavaScriptProject proj = this.createJavaProject("P", new String[] {}); |
| |
| IPath path = getExternalJCLPath(""); |
| IPath sourceAttachmentPath = new Path("jclMin.zip"); |
| JavaScriptCore.setIncludepathVariables( |
| new String[] {"TEST_LIB", "TEST_SRC"}, |
| new IPath[] {path, sourceAttachmentPath}, |
| null); |
| |
| ClasspathEntry cp = new ClasspathEntry( |
| IPackageFragmentRoot.K_SOURCE, |
| IIncludePathEntry.CPE_VARIABLE, |
| new Path("TEST_LIB"), |
| ClasspathEntry.INCLUDE_ALL, |
| ClasspathEntry.EXCLUDE_NONE, |
| new Path("TEST_SRC"), |
| null, |
| null, // specific output folder |
| false, |
| (IAccessRule[]) null, |
| false, |
| ClasspathEntry.NO_EXTRA_ATTRIBUTES); |
| IJavaScriptModelStatus status = JavaScriptConventions.validateClasspathEntry(proj, cp, false); |
| assertEquals( |
| "assertion failed: Source attachment path \'jclMin.zip\' for IIncludePathEntry must be absolute", |
| status.getMessage()); |
| } finally { |
| this.deleteProject("P"); |
| } |
| } |
| /* |
| * https://bugs.eclipse.org/bugs/show_bug.cgi?id=61214 |
| */ |
| public void testRemoveDuplicates() throws CoreException { |
| try { |
| IJavaScriptProject p1 = this.createJavaProject("P1", new String[] {""}); |
| IIncludePathEntry[] p1ClasspathEntries = new IIncludePathEntry[]{JavaScriptCore.newLibraryEntry(getExternalJCLPath(""), null, null, true)}; |
| setClasspath(p1, p1ClasspathEntries); |
| IJavaScriptProject p2 = this.createJavaProject("P2", new String[] {""}); |
| IIncludePathEntry[] p2ClasspathEntries = new IIncludePathEntry[]{ |
| JavaScriptCore.newProjectEntry(new Path("/P1")), |
| JavaScriptCore.newLibraryEntry(getExternalJCLPath(""), null, null, false) |
| }; |
| setClasspath(p2, p2ClasspathEntries); |
| |
| IIncludePathEntry[] classpath = ((JavaProject)p2).getExpandedClasspath(); |
| assertEquals("Unexpected number of classpath entries", 2, classpath.length); |
| assertEquals("Unexpected first entry", "/P1", classpath[0].getPath().toString()); |
| assertEquals("Unexpected second entry", getSystemJsPathString(), classpath[1].getPath().toOSString()); |
| } finally { |
| this.deleteProjects(new String[] {"P1", "P2"}); |
| } |
| } |
| } |