| /******************************************************************************* |
| * 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.util.HashMap; |
| import java.util.Map; |
| |
| import org.eclipse.core.resources.*; |
| import org.eclipse.core.runtime.*; |
| import org.eclipse.core.runtime.preferences.IEclipsePreferences; |
| import org.eclipse.wst.jsdt.core.*; |
| import org.eclipse.wst.jsdt.core.compiler.CharOperation; |
| import org.eclipse.wst.jsdt.internal.core.JavaModelManager; |
| import org.eclipse.wst.jsdt.internal.core.JavaModelStatus; |
| import org.eclipse.wst.jsdt.internal.core.UserLibraryJsGlobalScopeContainer; |
| import org.eclipse.wst.jsdt.internal.core.UserLibraryManager; |
| |
| import junit.framework.Test; |
| |
| public class ClasspathInitializerTests extends ModifyingResourceTests { |
| |
| public static class DefaultVariableInitializer implements VariablesInitializer.ITestInitializer { |
| Map variableValues; |
| |
| /* |
| * values is [<var name>, <var value>]* |
| */ |
| public DefaultVariableInitializer(String[] values) { |
| variableValues = new HashMap(); |
| for (int i = 0; i < values.length; i+=2) { |
| variableValues.put(values[i], new Path(values[i+1])); |
| } |
| } |
| |
| public void initialize(String variable) throws JavaScriptModelException { |
| if (variableValues == null) return; |
| JavaScriptCore.setIncludepathVariable( |
| variable, |
| (IPath)variableValues.get(variable), |
| null); |
| } |
| } |
| |
| public static class DefaultContainerInitializer implements ContainerInitializer.ITestInitializer { |
| |
| public static class DefaultContainer implements IJsGlobalScopeContainer { |
| char[][] libPaths; |
| public DefaultContainer(char[][] libPaths) { |
| this.libPaths = libPaths; |
| } |
| /** |
| * @deprecated Use {@link #getIncludepathEntries()} instead |
| */ |
| public IIncludePathEntry[] getClasspathEntries() { |
| return getIncludepathEntries(); |
| } |
| public IIncludePathEntry[] getIncludepathEntries() { |
| int length = this.libPaths.length; |
| IIncludePathEntry[] entries = new IIncludePathEntry[length]; |
| for (int j = 0; j < length; j++) { |
| IPath path = new Path(new String(this.libPaths[j])); |
| if (path.segmentCount() == 1) { |
| entries[j] = JavaScriptCore.newProjectEntry(path); |
| } else { |
| entries[j] = JavaScriptCore.newLibraryEntry(path, null, null); |
| } |
| } |
| return entries; |
| } |
| public String getDescription() { |
| return "Test container"; |
| } |
| public int getKind() { |
| return IJsGlobalScopeContainer.K_APPLICATION; |
| } |
| public IPath getPath() { |
| return new Path("org.eclipse.wst.jsdt.core.tests.model.TEST_CONTAINER"); |
| } |
| /* (non-Javadoc) |
| * @see org.eclipse.wst.jsdt.core.IJsGlobalScopeContainer#resolvedLibraryImport(java.lang.String) |
| */ |
| public String[] resolvedLibraryImport(String a) { |
| return new String[] {a}; |
| } |
| } |
| |
| Map containerValues; |
| CoreException exception; |
| |
| /* |
| * values is [<project name>, <lib path>[,<lib path>]* ]* |
| */ |
| public DefaultContainerInitializer(String[] values) { |
| containerValues = new HashMap(); |
| for (int i = 0; i < values.length; i+=2) { |
| final String projectName = values[i]; |
| final char[][] libPaths = CharOperation.splitOn(',', values[i+1].toCharArray()); |
| containerValues.put( |
| projectName, |
| newContainer(libPaths) |
| ); |
| } |
| } |
| protected DefaultContainer newContainer(final char[][] libPaths) { |
| return new DefaultContainer(libPaths); |
| } |
| public boolean allowFailureContainer() { |
| return true; |
| } |
| public void initialize(IPath containerPath, IJavaScriptProject project) throws CoreException { |
| if (containerValues == null) return; |
| try { |
| JavaScriptCore.setJsGlobalScopeContainer( |
| containerPath, |
| new IJavaScriptProject[] {project}, |
| new IJsGlobalScopeContainer[] {(IJsGlobalScopeContainer)containerValues.get(project.getElementName())}, |
| null); |
| } catch (CoreException e) { |
| this.exception = e; |
| throw e; |
| } |
| } |
| } |
| // Simple container initializer, which keeps setting container to null |
| // (30920 - stackoverflow when setting container to null) |
| public class NullContainerInitializer implements ContainerInitializer.ITestInitializer { |
| public boolean hasRun = false; |
| public boolean allowFailureContainer() { |
| return false; // allow the initializer to run again |
| } |
| public void initialize(IPath containerPath, IJavaScriptProject project) throws CoreException { |
| hasRun = true; |
| JavaScriptCore.setJsGlobalScopeContainer( |
| containerPath, |
| new IJavaScriptProject[] {project}, |
| new IJsGlobalScopeContainer[] { null }, |
| null); |
| } |
| } |
| |
| public ClasspathInitializerTests(String name) { |
| super(name); |
| } |
| public static Test suite() { |
| return buildModelTestSuite(ClasspathInitializerTests.class); |
| } |
| // 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_NAMES = new String[] { "testContainerInitializer12" }; |
| // Numbers of tests to run: "test<number>" will be run for each number of this array |
| // TESTS_NUMBERS = new int[] { 2, 12 }; |
| // Range numbers of tests to run: all tests between "test<first>" and "test<last>" will be run for { first, last } |
| // TESTS_RANGE = new int[] { 16, -1 }; |
| } |
| protected void tearDown() throws Exception { |
| // Cleanup caches |
| JavaModelManager manager = JavaModelManager.getJavaModelManager(); |
| manager.containers = new HashMap(5); |
| manager.variables = new HashMap(5); |
| |
| super.tearDown(); |
| } |
| public void testContainerInitializer01() throws CoreException { |
| try { |
| createProject("P1"); |
| createFile("/P1/lib.jar", ""); |
| ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", "/P1/lib.jar"})); |
| IJavaScriptProject p2 = createJavaProject( |
| "P2", |
| new String[] {}, |
| new String[] {"org.eclipse.wst.jsdt.core.tests.model.TEST_CONTAINER"}); |
| IPackageFragmentRoot root = p2.getPackageFragmentRoot(getFile("/P1/lib.jar")); |
| assertTrue("/P1/lib.jar should exist", root.exists()); |
| } finally { |
| stopDeltas(); |
| deleteProject("P1"); |
| deleteProject("P2"); |
| } |
| } |
| public void testContainerInitializer02() throws CoreException { |
| try { |
| createProject("P1"); |
| createFile("/P1/lib.jar", ""); |
| ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", "/P1/lib.jar"})); |
| IJavaScriptProject p2 = createJavaProject( |
| "P2", |
| new String[] {}, |
| new String[] {"org.eclipse.wst.jsdt.core.tests.model.TEST_CONTAINER"}); |
| |
| // simulate state on startup |
| simulateExitRestart(); |
| |
| startDeltas(); |
| p2.getResolvedIncludepath(true); |
| |
| assertDeltas( |
| "Unexpected delta on startup", |
| "" |
| ); |
| } finally { |
| stopDeltas(); |
| deleteProject("P1"); |
| deleteProject("P2"); |
| } |
| } |
| public void testContainerInitializer03() throws CoreException { |
| try { |
| createProject("P1"); |
| createFile("/P1/lib.jar", ""); |
| ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", "/P1/lib.jar"})); |
| createJavaProject( |
| "P2", |
| new String[] {}, |
| new String[] {"org.eclipse.wst.jsdt.core.tests.model.TEST_CONTAINER"}); |
| |
| // change value of TEST_CONTAINER |
| createFile("/P1/lib2.jar", ""); |
| ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", "/P1/lib2.jar"})); |
| |
| // simulate state on startup |
| simulateExitRestart(); |
| |
| startDeltas(); |
| getJavaProject("P2").getResolvedIncludepath(true); |
| |
| assertDeltas( |
| "Unexpected delta on startup", |
| "P2[*]: {CHILDREN}\n" + |
| " /P1/lib.jar[*]: {REMOVED FROM CLASSPATH}\n" + |
| " /P1/lib2.jar[*]: {ADDED TO CLASSPATH}" |
| ); |
| } finally { |
| stopDeltas(); |
| deleteProject("P1"); |
| deleteProject("P2"); |
| } |
| } |
| /* Ensure that initializer is not callled when resource tree is locked. |
| * (regression test for bug 29585 Core Exception as resource tree is locked initializing classpath container) |
| */ |
| public void testContainerInitializer04() throws CoreException { |
| try { |
| createProject("P1"); |
| createFile("/P1/lib.jar", ""); |
| DefaultContainerInitializer initializer = new DefaultContainerInitializer(new String[] {"P2", "/P1/lib.jar"}); |
| ContainerInitializer.setInitializer(initializer); |
| createJavaProject( |
| "P2", |
| new String[] {""}, |
| new String[] {"org.eclipse.wst.jsdt.core.tests.model.TEST_CONTAINER"}); |
| |
| // simulate state on startup |
| simulateExitRestart(); |
| |
| startDeltas(); |
| createFile("/P2/X.js", "public class X {}"); |
| |
| assertEquals("Should not get exception", null, initializer.exception); |
| |
| assertDeltas( |
| "Unexpected delta on startup", |
| "P2[*]: {CHILDREN}\n" + |
| " <project root>[*]: {CHILDREN}\n" + |
| " <default>[*]: {CHILDREN}\n" + |
| " X.java[+]: {}" |
| ); |
| } finally { |
| stopDeltas(); |
| deleteProject("P1"); |
| deleteProject("P2"); |
| } |
| } |
| /* |
| * 30920 - Stack overflow when container resolved to null |
| */ |
| public void testContainerInitializer05() throws CoreException { |
| try { |
| NullContainerInitializer nullInitializer = new NullContainerInitializer(); |
| ContainerInitializer.setInitializer(nullInitializer); |
| createJavaProject( |
| "P1", |
| new String[] {""}, |
| new String[] {"org.eclipse.wst.jsdt.core.tests.model.TEST_CONTAINER"}); |
| |
| // simulate state on startup |
| simulateExitRestart(); |
| |
| startDeltas(); |
| |
| // will trigger classpath resolution (with null container value) |
| createFile("/P1/X.js", "public class X {}"); |
| assertDeltas( |
| "Unexpected delta on startup", |
| "P1[*]: {CHILDREN}\n" + |
| " <project root>[*]: {CHILDREN}\n" + |
| " <default>[*]: {CHILDREN}\n" + |
| " X.java[+]: {}" |
| ); |
| assertTrue("initializer did not run", nullInitializer.hasRun); |
| |
| // next cp resolution request will rerun the initializer |
| waitForAutoBuild(); |
| nullInitializer.hasRun = false; // reset |
| getJavaProject("P1").getResolvedIncludepath(true); |
| assertTrue("initializer did not run", nullInitializer.hasRun); // initializer should have run again (since keep setting to null) |
| |
| // assigning new (non-null) value to container |
| waitForAutoBuild(); |
| createFile("/P1/lib.jar", ""); |
| ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P1", "/P1/lib.jar"})); |
| clearDeltas(); |
| getJavaProject("P1").getResolvedIncludepath(true); |
| assertDeltas( |
| "Unexpected delta after setting container", |
| "P1[*]: {CHILDREN}\n" + |
| " lib.jar[*]: {ADDED TO CLASSPATH}" |
| ); |
| |
| } catch (StackOverflowError e) { |
| e.printStackTrace(); |
| assertTrue("stack overflow assigning container", false); |
| } finally { |
| stopDeltas(); |
| deleteProject("P1"); |
| } |
| } |
| /* |
| * Ensures that running the initializer during a reconcile operation just after workspace startup |
| * doesn't throw a NPE |
| * (regression test for bug 48818 NPE in delta processor) |
| */ |
| public void testContainerInitializer06() throws CoreException { |
| IJavaScriptUnit workingCopy = null; |
| try { |
| createProject("P1"); |
| ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", ""})); |
| createJavaProject( |
| "P2", |
| new String[] {"src"}, |
| new String[] {"org.eclipse.wst.jsdt.core.tests.model.TEST_CONTAINER"}); |
| createFile( |
| "/P2/src/X,java", |
| "public class X {\n" + |
| "}" |
| ); |
| |
| // change value of TEST_CONTAINER |
| ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P2", "/P1"})); |
| |
| // simulate state on startup |
| simulateExitRestart(); |
| |
| startDeltas(); |
| workingCopy = getCompilationUnit("/P2/src/X.js"); |
| workingCopy.becomeWorkingCopy(null); |
| |
| assertDeltas( |
| "Unexpected delta on startup", |
| "P2[*]: {CHILDREN}\n" + |
| " src[*]: {CHILDREN}\n" + |
| " <default>[*]: {CHILDREN}\n" + |
| " [Working copy] X.java[+]: {PRIMARY WORKING COPY}" |
| ); |
| } finally { |
| stopDeltas(); |
| if (workingCopy != null) workingCopy.discardWorkingCopy(); |
| deleteProject("P1"); |
| deleteProject("P2"); |
| } |
| } |
| /* |
| * Ensure that an OperationCanceledException goes through |
| * (regression test for bug 59363 Should surface cancellation exceptions) |
| */ |
| public void testContainerInitializer07() throws CoreException { |
| try { |
| boolean gotException = false; |
| try { |
| ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P1", "/P1/lib.jar"}) { |
| public void initialize(IPath containerPath, IJavaScriptProject project) throws CoreException { |
| throw new OperationCanceledException("test"); |
| }}); |
| IJavaScriptProject p1 = createJavaProject( |
| "P1", |
| new String[] {}, |
| new String[] {"org.eclipse.wst.jsdt.core.tests.model.TEST_CONTAINER"}); |
| p1.getResolvedIncludepath(true); |
| } catch (OperationCanceledException e) { |
| gotException = true; |
| } |
| assertTrue("Should get an OperationCanceledException", gotException); |
| } finally { |
| stopDeltas(); |
| deleteProject("P1"); |
| } |
| } |
| /* |
| * Ensure that the stack doesn't blow up if initializer is missbehaving |
| * (regression test for bug 61052 Flatten cp container initialization) |
| */ |
| public void testContainerInitializer08() throws CoreException { |
| final int projectLength = 10; |
| final String[] projects = new String[projectLength]; |
| for (int i = 0; i < projectLength; i++) { |
| projects[i] = "P" + i; |
| } |
| try { |
| String[] projectRefs = new String[(projectLength-1) * 2]; |
| for (int i = 0; i < projectLength-1; i++) { |
| projectRefs[i*2] = "P" + i; |
| projectRefs[(i*2)+1] = "/P" + i + "/test.jar"; |
| } |
| ContainerInitializer.setInitializer(new DefaultContainerInitializer(projectRefs) { |
| void foo(int n) { |
| if (n > 0) { |
| foo(n-1); |
| return; |
| } |
| IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot(); |
| for (int i = 0; i < projectLength-1; i++) { |
| try { |
| JavaScriptCore.create(root.getProject(projects[i])).getResolvedIncludepath(true); |
| } catch (JavaScriptModelException e) { |
| // project doesn't exist: ignore |
| } |
| } |
| } |
| public void initialize(IPath containerPath, IJavaScriptProject project) throws CoreException { |
| foo(500); |
| super.initialize(containerPath, project); |
| } |
| }); |
| JavaScriptCore.run(new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| for (int i = 0; i < projectLength; i++) { |
| createProject(projects[i]); |
| editFile( |
| "/" + projects[i] + "/.project", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<projectDescription>\n" + |
| " <name>" + projects[i] + "</name>\n" + |
| " <comment></comment>\n" + |
| " <projects>\n" + |
| (i == 0 ? "" : "<project>" + projects[i-1] + "</project>\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>" |
| ); |
| createFile( |
| "/" + projects[i] + "/.classpath", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| (i == 0 ? "" : "<classpathentry kind=\"src\" path=\"/" + projects[i-1] + "\"/>\n") + |
| " <classpathentry kind=\"con\" path=\"org.eclipse.wst.jsdt.core.tests.model.TEST_CONTAINER\"/>\n" + |
| " <classpathentry kind=\"output\" path=\"\"/>\n" + |
| "</classpath>" |
| ); |
| } |
| } |
| }, null); |
| getJavaProject("P0").getResolvedIncludepath(true); |
| } finally { |
| stopDeltas(); |
| deleteProjects(projects); |
| } |
| } |
| /* |
| * Ensure that a StackOverFlowError is not thrown if the initializer asks for the resolved classpath |
| * that is being resolved. |
| * (regression test for bug 61040 Should add protect for reentrance to #getResolvedClasspath) |
| */ |
| public void testContainerInitializer09() throws CoreException { |
| try { |
| ClasspathInitializerTests.DefaultContainerInitializer initializer = new ClasspathInitializerTests.DefaultContainerInitializer(new String[] {"P1", "/P1/lib.jar"}) { |
| protected DefaultContainer newContainer(char[][] libPaths) { |
| return new DefaultContainer(libPaths) { |
| /** |
| * @deprecated Use {@link #getIncludepathEntries()} instead |
| */ |
| public IIncludePathEntry[] getClasspathEntries() { |
| return getIncludepathEntries(); |
| } |
| |
| public IIncludePathEntry[] getIncludepathEntries() { |
| try { |
| getJavaProject("P1").getResolvedIncludepath(true); |
| } catch (JavaScriptModelException e) { |
| // project doesn't exist: ignore |
| } |
| return super.getIncludepathEntries(); |
| } |
| }; |
| } |
| }; |
| ContainerInitializer.setInitializer(initializer); |
| JavaScriptCore.run(new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| createProject("P1"); |
| editFile( |
| "/P1/.project", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<projectDescription>\n" + |
| " <name>P1</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>" |
| ); |
| createFile( |
| "/P1/.classpath", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry kind=\"con\" path=\"org.eclipse.wst.jsdt.core.tests.model.TEST_CONTAINER\"/>\n" + |
| " <classpathentry kind=\"output\" path=\"\"/>\n" + |
| "</classpath>" |
| ); |
| } |
| }, null); |
| getJavaProject("P1").getResolvedIncludepath(true); |
| } finally { |
| stopDeltas(); |
| ContainerInitializer.setInitializer(null); |
| deleteProject("P1"); |
| } |
| } |
| /* |
| * Ensure that creating a Java project initializes a container and refreshes the external jar at the same time |
| * without throwing a ConcurrentModificationException |
| * (regression test for bug 63534 ConcurrentModificationException after "catching up") |
| */ |
| public void testContainerInitializer10() throws CoreException { |
| class LogListener implements ILogListener { |
| IStatus log; |
| public void logging(IStatus status, String plugin) { |
| this.log = status; |
| } |
| } |
| LogListener listener = new LogListener(); |
| try { |
| Platform.addLogListener(listener); |
| final IJavaScriptProject p1 = createJavaProject("P1"); |
| final IJavaScriptProject p2 = createJavaProject("P2"); |
| ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P3", "/P1"}) { |
| public void initialize(IPath containerPath, IJavaScriptProject project) throws CoreException { |
| super.initialize(containerPath, project); |
| getJavaModel().refreshExternalArchives(new IJavaScriptElement[] {p1}, null); |
| } |
| }); |
| getWorkspace().run(new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| p2.setRawIncludepath(new IIncludePathEntry[] {JavaScriptCore.newSourceEntry(new Path("/P2/src"))}, null); |
| createProject("P3"); |
| editFile( |
| "/P3/.project", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<projectDescription>\n" + |
| " <name>P3</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>\n" |
| ); |
| createFile( |
| "/P3/.classpath", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry kind=\"src\" path=\"\"/>\n" + |
| " <classpathentry kind=\"var\" path=\"JCL_LIB\"/>\n" + |
| " <classpathentry kind=\"con\" path=\"org.eclipse.wst.jsdt.core.tests.model.TEST_CONTAINER\"/>\n" + |
| " <classpathentry kind=\"output\" path=\"\"/>\n" + |
| "</classpath>" |
| ); |
| } |
| }, null); |
| |
| assertEquals("Should not get any exception in log", null, listener.log); |
| } finally { |
| Platform.removeLogListener(listener); |
| deleteProject("P1"); |
| deleteProject("P2"); |
| deleteProject("P3"); |
| } |
| } |
| /* |
| * Ensure that a classpath initializer is not run on shutdown |
| * (regression test for bug 93941 Classpath initialization on shutdown) |
| */ |
| public void testContainerInitializer11() throws CoreException { |
| boolean hasExited = false; |
| try { |
| ContainerInitializer.setInitializer(null); |
| createJavaProject( |
| "P", |
| new String[] {}, |
| new String[] {"org.eclipse.wst.jsdt.core.tests.model.TEST_CONTAINER"}); |
| simulateExitRestart(); |
| ClasspathInitializerTests.DefaultContainerInitializer initializer = new ClasspathInitializerTests.DefaultContainerInitializer(new String[] {}) { |
| public void initialize(IPath containerPath,IJavaScriptProject project) throws CoreException { |
| assertTrue("Should not initialize container on shutdown", false); |
| } |
| }; |
| ContainerInitializer.setInitializer(initializer); |
| simulateExit(); |
| hasExited = true; |
| } finally { |
| ContainerInitializer.setInitializer(null); |
| if (hasExited) |
| simulateRestart(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Ensure that the initializer is removed from the cache when the project is deleted |
| * (regression test for bug 116072 cached classpath containers not removed when project deleted) |
| */ |
| public void testContainerInitializer12() throws CoreException { |
| try { |
| ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P1", "/P1/lib.jar"})); |
| IJavaScriptProject project = createJavaProject( |
| "P1", |
| new String[] {}, |
| new String[] {"org.eclipse.wst.jsdt.core.tests.model.TEST_CONTAINER"}); |
| createFile("/P1/lib.jar", ""); |
| IPackageFragmentRoot root = project.getPackageFragmentRoot(getFile("/P1/lib.jar")); |
| assertTrue("/P1/lib.jar should exist", root.exists()); |
| deleteProject("P1"); |
| |
| class Initializer extends DefaultContainerInitializer { |
| boolean initialized; |
| public Initializer(String[] args) { |
| super(args); |
| } |
| public void initialize(IPath containerPath, IJavaScriptProject p) throws CoreException { |
| super.initialize(containerPath, p); |
| this.initialized = true; |
| } |
| } |
| Initializer initializer = new Initializer(new String[] {"P1", "/P1/lib.jar"}); |
| ContainerInitializer.setInitializer(initializer); |
| createJavaProject( |
| "P1", |
| new String[] {}, |
| new String[] {"org.eclipse.wst.jsdt.core.tests.model.TEST_CONTAINER"}); |
| createFile("/P1/lib.jar", ""); |
| assertTrue("/P1/lib.jar should exist", root.exists()); |
| assertTrue("Should have been initialized", initializer.initialized); |
| } finally { |
| stopDeltas(); |
| deleteProject("P1"); |
| } |
| } |
| |
| /* |
| * Ensures that no resource deta is reported if a container that was not initialized is initialized with null |
| * (regression test for bug 149043 Unresolvable classpath container leads to lots of scheduled jobs) |
| */ |
| public void testContainerInitializer13() throws CoreException { |
| IResourceChangeListener listener = new IResourceChangeListener() { |
| StringBuffer buffer = new StringBuffer(); |
| public void resourceChanged(IResourceChangeEvent event) { |
| this.buffer.append(event.getDelta().findMember(new Path("/P1"))); |
| } |
| public String toString() { |
| return this.buffer.toString(); |
| } |
| }; |
| try { |
| NullContainerInitializer nullInitializer = new NullContainerInitializer(); |
| ContainerInitializer.setInitializer(nullInitializer); |
| IJavaScriptProject project = createJavaProject( |
| "P1", |
| new String[] {}, |
| new String[] {"org.eclipse.wst.jsdt.core.tests.model.TEST_CONTAINER"}); |
| |
| // simulate state on startup |
| simulateExitRestart(); |
| |
| getWorkspace().addResourceChangeListener(listener, IResourceChangeEvent.POST_CHANGE); |
| |
| // force resolution of container |
| project.findPackageFragmentRoots(project.getRawIncludepath()[0]); |
| |
| assertEquals( |
| "Unexpected resource delta on startup", |
| "", |
| listener.toString() |
| ); |
| } finally { |
| getWorkspace().removeResourceChangeListener(listener); |
| deleteProject("P1"); |
| } |
| } |
| |
| /* |
| * Ensures that a misbehaving container (that initializes another project than the one asked for) doesn't cause |
| * the container to be initialized again |
| * (regression test for bug 160005 Add protection about misbehaving container initializer) |
| */ |
| public void testContainerInitializer14() throws CoreException { |
| try { |
| createProject("P1"); |
| createFile("/P1/lib.jar", ""); |
| class Container extends DefaultContainerInitializer { |
| int initializeCount = 0; |
| Container(String[] values) { |
| super(values); |
| } |
| public void initialize(IPath containerPath, IJavaScriptProject project) throws CoreException { |
| this.initializeCount++; |
| super.initialize(containerPath, getJavaProject("P1")); |
| } |
| } |
| Container container = new Container(new String[] {"P2", "/P1/lib.jar"}); |
| ContainerInitializer.setInitializer(container); |
| IJavaScriptProject p2 = createJavaProject( |
| "P2", |
| new String[] {}, |
| new String[] {"org.eclipse.wst.jsdt.core.tests.model.TEST_CONTAINER"}); |
| p2.getResolvedIncludepath(true); |
| assertEquals("Unexpected number of initalizations", 1, container.initializeCount); |
| } finally { |
| stopDeltas(); |
| deleteProject("P1"); |
| deleteProject("P2"); |
| } |
| } |
| |
| /* |
| * Ensures that if a container is misbehaving (it doesn't initialize a project when asked for), |
| * then the resulting container's classpath is not null |
| * (regression test for bug 161846 Expanding a java project with invalid classpath container entries in Project Explorer causes CPU to stay at 100%) |
| */ |
| public void testContainerInitializer15() throws CoreException { |
| try { |
| class Container extends DefaultContainerInitializer { |
| Container(String[] values) { |
| super(values); |
| } |
| public void initialize(IPath containerPath, IJavaScriptProject project) throws CoreException { |
| } |
| } |
| Container container = new Container(new String[] {"P1", "/P1/lib.jar"}); |
| ContainerInitializer.setInitializer(container); |
| IJavaScriptProject p1 = createJavaProject( |
| "P1", |
| new String[] {}, |
| new String[] {"org.eclipse.wst.jsdt.core.tests.model.TEST_CONTAINER"}); |
| IJsGlobalScopeContainer JsGlobalScopeContainer = JavaScriptCore.getJsGlobalScopeContainer(new Path("org.eclipse.wst.jsdt.core.tests.model.TEST_CONTAINER"), p1); |
| assertClasspathEquals(JsGlobalScopeContainer.getIncludepathEntries(), ""); |
| } finally { |
| stopDeltas(); |
| deleteProject("P1"); |
| } |
| } |
| /* |
| * Ensure that an initializer cannot return a project entry that points to the project of the container (cycle). |
| */ |
| public void testContainerInitializer16() throws CoreException { |
| try { |
| ContainerInitializer.setInitializer(new DefaultContainerInitializer(new String[] {"P1", "/P1"})); |
| JavaScriptModelException exception = null; |
| try { |
| IJavaScriptProject p1 = createJavaProject( |
| "P1", |
| new String[] {}, |
| new String[] {"org.eclipse.wst.jsdt.core.tests.model.TEST_CONTAINER"}); |
| p1.getResolvedIncludepath(true); |
| } catch (JavaScriptModelException e) { |
| exception = e; |
| } |
| assertExceptionEquals( |
| "Unexpected expection", |
| "Project cannot reference itself: P1", |
| exception); |
| } finally { |
| stopDeltas(); |
| deleteProject("P1"); |
| } |
| } |
| public void testVariableInitializer01() throws CoreException { |
| try { |
| createProject("P1"); |
| createFile("/P1/lib.jar", ""); |
| VariablesInitializer.setInitializer(new DefaultVariableInitializer(new String[] {"TEST_LIB", "/P1/lib.jar"})); |
| IJavaScriptProject p2 = createJavaProject("P2", new String[] {}, new String[] {"TEST_LIB"}); |
| IPackageFragmentRoot root = p2.getPackageFragmentRoot(getFile("/P1/lib.jar")); |
| assertTrue("/P1/lib.jar should exist", root.exists()); |
| } finally { |
| deleteProject("P1"); |
| deleteProject("P2"); |
| VariablesInitializer.reset(); |
| } |
| } |
| public void testVariableInitializer02() throws CoreException { |
| try { |
| createProject("P1"); |
| createFile("/P1/lib.jar", ""); |
| createFile("/P1/src.zip", ""); |
| VariablesInitializer.setInitializer(new DefaultVariableInitializer(new String[] { |
| "TEST_LIB", "/P1/lib.jar", |
| "TEST_SRC", "/P1/src.zip", |
| "TEST_ROOT", "src", |
| })); |
| IJavaScriptProject p2 = createJavaProject("P2", new String[] {}, new String[] {"TEST_LIB,TEST_SRC,TEST_ROOT"}); |
| IPackageFragmentRoot root = p2.getPackageFragmentRoot(getFile("/P1/lib.jar")); |
| assertEquals("Unexpected source attachment path", "/P1/src.zip", root.getSourceAttachmentPath().toString()); |
| assertEquals("Unexpected source attachment root path", "src", root.getSourceAttachmentRootPath().toString()); |
| } finally { |
| deleteProject("P1"); |
| deleteProject("P2"); |
| VariablesInitializer.reset(); |
| } |
| } |
| public void testVariableInitializer03() throws CoreException { |
| try { |
| createProject("P1"); |
| createFile("/P1/lib.jar", ""); |
| createFile("/P1/src.zip", ""); |
| String[] variableValues = new String[] { |
| "TEST_LIB", "/P1/lib.jar", |
| "TEST_SRC", "/P1/src.zip", |
| "TEST_ROOT", "src", |
| }; |
| VariablesInitializer.setInitializer(new DefaultVariableInitializer(variableValues)); |
| createJavaProject("P2", new String[] {}, new String[] {"TEST_LIB,TEST_SRC,TEST_ROOT"}); |
| |
| // simulate state on startup |
| simulateExitRestart(); |
| |
| startDeltas(); |
| //JavaModelManager.CP_RESOLVE_VERBOSE=true; |
| getJavaProject("P2").getResolvedIncludepath(true); |
| |
| assertDeltas( |
| "Unexpected delta on startup", |
| "" |
| ); |
| } finally { |
| //JavaModelManager.CP_RESOLVE_VERBOSE=false; |
| stopDeltas(); |
| deleteProject("P1"); |
| deleteProject("P2"); |
| VariablesInitializer.reset(); |
| } |
| } |
| public void testVariableInitializer04() throws CoreException { |
| try { |
| final StringBuffer buffer = new StringBuffer(); |
| VariablesInitializer.setInitializer(new VariablesInitializer.ITestInitializer() { |
| public void initialize(String variable) throws JavaScriptModelException { |
| buffer.append("Initializing " + variable + "\n"); |
| IPath path = new Path(variable.toLowerCase()); |
| buffer.append("Setting variable " + variable + " to " + path + "\n"); |
| JavaScriptCore.setIncludepathVariable(variable, path, null); |
| } |
| }); |
| createJavaProject("P", new String[] {}, new String[] {"TEST_LIB,TEST_SRC,TEST_ROOT"}); |
| assertEquals( |
| "Initializing TEST_LIB\n" + |
| "Setting variable TEST_LIB to test_lib\n", |
| buffer.toString()); |
| } finally { |
| deleteProject("P"); |
| VariablesInitializer.reset(); |
| } |
| } |
| public void testVariableInitializer05() throws CoreException { |
| try { |
| final StringBuffer buffer = new StringBuffer(); |
| VariablesInitializer.setInitializer(new VariablesInitializer.ITestInitializer() { |
| public void initialize(String variable) throws JavaScriptModelException { |
| buffer.append("Initializing " + variable + "\n"); |
| IPath path = new Path(variable.toLowerCase()); |
| JavaScriptCore.getIncludepathVariable("TEST_SRC"); |
| buffer.append("Setting variable " + variable + " to " + path + "\n"); |
| JavaScriptCore.setIncludepathVariable(variable, path, null); |
| } |
| }); |
| createJavaProject("P", new String[] {}, new String[] {"TEST_LIB,TEST_SRC,TEST_ROOT"}); |
| assertEquals( |
| "Initializing TEST_LIB\n" + |
| "Initializing TEST_SRC\n" + |
| "Setting variable TEST_SRC to test_src\n" + |
| "Setting variable TEST_LIB to test_lib\n", |
| buffer.toString()); |
| } finally { |
| deleteProject("P"); |
| VariablesInitializer.reset(); |
| } |
| } |
| /* |
| * Ensures that if the initializer doesn't initialize a variable, it can be |
| * initialized later on. |
| */ |
| public void testVariableInitializer06() throws CoreException { |
| try { |
| final StringBuffer buffer = new StringBuffer(); |
| VariablesInitializer.setInitializer(new VariablesInitializer.ITestInitializer() { |
| public void initialize(String variable) { |
| // do nothing |
| buffer.append("Ignoring request to initialize"); |
| } |
| }); |
| IPath path = JavaScriptCore.getIncludepathVariable("TEST_SRC"); |
| assertEquals( |
| "Unexpected value of TEST_SRC after initializer was called", |
| null, |
| path); |
| IPath varValue = new Path("src.zip"); |
| JavaScriptCore.setIncludepathVariable("TEST_SRC", varValue, null); |
| path = JavaScriptCore.getIncludepathVariable("TEST_SRC"); |
| assertEquals( |
| "Unexpected value of TEST_SRC after setting it", |
| varValue, |
| path); |
| } finally { |
| VariablesInitializer.reset(); |
| } |
| } |
| public void testVariableInitializer07() throws CoreException { |
| try { |
| createProject("P1"); |
| createFile("/P1/lib.jar", ""); |
| createFile("/P1/src.zip", ""); |
| String[] variableValues = new String[] { |
| "TEST_LIB", "/P1/lib.jar", |
| "TEST_SRC", "/P1/src.zip", |
| "TEST_ROOT", "src", |
| }; |
| VariablesInitializer.setInitializer(new DefaultVariableInitializer(variableValues)); |
| createJavaProject("P2", new String[] {}, new String[] {"TEST_LIB,TEST_SRC,TEST_ROOT"}); |
| |
| // change value of TEST_LIB |
| createFile("/P1/lib2.jar", ""); |
| VariablesInitializer.setInitializer(new DefaultVariableInitializer(new String[] { |
| "TEST_LIB", "/P1/lib2.jar", |
| "TEST_SRC", "/P1/src.zip", |
| "TEST_ROOT", "src", |
| })); |
| |
| // simulate state on startup |
| simulateExitRestart(); |
| |
| startDeltas(); |
| //JavaModelManager.CP_RESOLVE_VERBOSE=true; |
| getJavaProject("P2").getResolvedIncludepath(true); |
| |
| assertDeltas( |
| "Unexpected delta on startup", |
| "P2[*]: {CHILDREN}\n" + |
| " /P1/lib.jar[*]: {REMOVED FROM CLASSPATH}\n" + |
| " /P1/lib2.jar[*]: {ADDED TO CLASSPATH}" |
| ); |
| } finally { |
| //JavaModelManager.CP_RESOLVE_VERBOSE=false; |
| stopDeltas(); |
| deleteProject("P1"); |
| deleteProject("P2"); |
| VariablesInitializer.reset(); |
| } |
| } |
| /* |
| * Ensure that an OperationCanceledException goes through |
| * (regression test for bug 59363 Should surface cancellation exceptions) |
| */ |
| |
| public void testVariableInitializer08() throws CoreException { |
| try { |
| boolean gotException = false; |
| try { |
| VariablesInitializer.setInitializer(new DefaultVariableInitializer(new String[] {"TEST_LIB", "/P1/lib.jar"}) { |
| public void initialize(String variable) throws JavaScriptModelException { |
| throw new OperationCanceledException("test"); |
| } |
| }); |
| IJavaScriptProject p1 = createJavaProject("P1", new String[] {}, new String[] {"TEST_LIB"}); |
| p1.getResolvedIncludepath(true); |
| } catch (OperationCanceledException e) { |
| gotException = true; |
| } |
| assertTrue("Should get an OperationCanceledException", gotException); |
| } finally { |
| deleteProject("P1"); |
| VariablesInitializer.reset(); |
| } |
| } |
| |
| /* |
| * Ensure that removing a classpath variable while initializing it doesn't throw a StackOverFlowError |
| * (regression test for bug 112609 StackOverflow when initializing Java Core) |
| */ |
| public void testVariableInitializer09() throws CoreException { |
| try { |
| VariablesInitializer.setInitializer(new DefaultVariableInitializer(new String[] {"TEST_LIB", "/P1/lib.jar"}) { |
| public void initialize(String variable) throws JavaScriptModelException { |
| JavaScriptCore.removeIncludepathVariable("TEST_LIB", null); |
| } |
| }); |
| IJavaScriptProject p1 = createJavaProject("P1", new String[] {}, new String[] {"TEST_LIB"}); |
| IIncludePathEntry[] resolvedClasspath = p1.getResolvedIncludepath(true); |
| assertClasspathEquals( |
| resolvedClasspath, |
| "" |
| ); |
| } finally { |
| deleteProject("P1"); |
| VariablesInitializer.reset(); |
| } |
| } |
| /* |
| * Ensures that not initializing a classpath variable and asking for its value returns null |
| * (regression test for bug 113110 TestFailures in DebugSuite) |
| */ |
| public void testVariableInitializer10() throws CoreException { |
| try { |
| VariablesInitializer.setInitializer(new DefaultVariableInitializer(new String[] {"TEST_LIB", "/P1/lib.jar"}) { |
| public void initialize(String variable) throws JavaScriptModelException { |
| // don't initialize |
| } |
| }); |
| // force resolution |
| JavaScriptCore.getIncludepathVariable("TEST_LIB"); |
| // second call should still be null |
| assertEquals("TEST_LIB should be null", null, JavaScriptCore.getIncludepathVariable("TEST_LIB")); |
| } finally { |
| deleteProject("P1"); |
| VariablesInitializer.reset(); |
| } |
| } |
| /** |
| * Bug 125965: [prefs] "Export/Import preferences" should let user to choose wich preference to export/import |
| * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=125965" |
| */ |
| public void testVariableInitializer11() throws CoreException { |
| try { |
| // Create initializer |
| String varName = "TEST_LIB"; |
| String initialValue = "/P1/lib.jar"; |
| String newValue = "/tmp/file.jar"; |
| VariablesInitializer.setInitializer(new DefaultVariableInitializer(new String[] {varName, initialValue})); |
| assertEquals("JavaScriptCore classpath value should have been initialized", JavaScriptCore.getIncludepathVariable(varName).toString(), initialValue); |
| |
| // Modify preference |
| JavaModelManager manager = JavaModelManager.getJavaModelManager(); |
| IEclipsePreferences preferences = manager.getInstancePreferences(); |
| preferences.put(JavaModelManager.CP_VARIABLE_PREFERENCES_PREFIX+varName, newValue); |
| |
| // verify that JavaScriptCore preferences have been reset |
| assertEquals("JavaScriptCore classpath value should be unchanged", JavaScriptCore.getIncludepathVariable(varName).toString(), initialValue); |
| assertEquals("JavaScriptCore preferences value should be unchanged", preferences.get(varName, "X"), initialValue); |
| } finally { |
| VariablesInitializer.reset(); |
| } |
| } |
| |
| /** |
| * @bug 138599: [model][classpath] Need a way to mark a classpath variable as deprecated |
| * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=138599" |
| */ |
| public void testVariableInitializerDeprecated() throws CoreException { |
| try { |
| // Create initializer |
| String varName = "TEST_DEPRECATED"; |
| String filePath = "/P1/lib.jar"; |
| VariablesInitializer.setInitializer(new DefaultVariableInitializer(new String[] {varName, filePath})); |
| assertEquals("JavaScriptCore classpath value should have been initialized", JavaScriptCore.getIncludepathVariable(varName).toString(), filePath); |
| |
| // Verify that Classpath Variable is deprecated |
| assertEquals("JavaScriptCore classpath variable should be deprecated", "Test deprecated flag", JavaScriptCore.getIncludepathVariableDeprecationMessage(varName)); |
| |
| // Create project |
| IJavaScriptProject project = createJavaProject("P1"); |
| createFile("/P1/lib.jar", ""); |
| IIncludePathEntry variable = JavaScriptCore.newVariableEntry(new Path("TEST_DEPRECATED"), null, null); |
| IJavaScriptModelStatus status = JavaScriptConventions.validateClasspathEntry(project, variable, false); |
| assertStatus("Classpath variable 'TEST_DEPRECATED' in project P1 is deprecated: 'Test deprecated flag'", status); |
| assertFalse("Status should not be OK", status.isOK()); |
| assertEquals("Status should have WARNING severity", IStatus.WARNING, status.getSeverity()); |
| assertEquals("Status should have deprecated code", IJavaScriptModelStatusConstants.DEPRECATED_VARIABLE, status.getCode()); |
| } finally { |
| VariablesInitializer.reset(); |
| deleteProject("P1"); |
| } |
| } |
| public void testVariableInitializerUnboundAndDeprecated() throws CoreException { |
| try { |
| // Create initializer |
| String varName = "TEST_DEPRECATED"; |
| String filePath = "/P1/lib.jar"; |
| VariablesInitializer.setInitializer(new DefaultVariableInitializer(new String[] {varName, filePath})); |
| assertEquals("JavaScriptCore classpath value should have been initialized", JavaScriptCore.getIncludepathVariable(varName).toString(), filePath); |
| |
| // Verify that Classpath Variable is deprecated |
| assertEquals("JavaScriptCore classpath variable should be deprecated", "Test deprecated flag", JavaScriptCore.getIncludepathVariableDeprecationMessage(varName)); |
| |
| // Create project |
| IJavaScriptProject project = createJavaProject("P1"); |
| IIncludePathEntry variable = JavaScriptCore.newVariableEntry(new Path("TEST_DEPRECATED"), null, null); |
| IJavaScriptModelStatus status = JavaScriptConventions.validateClasspathEntry(project, variable, false); |
| assertStatus("Project P1 is missing required library: 'lib.jar'", status); |
| assertFalse("Status should not be OK", status.isOK()); |
| assertEquals("Status should have WARNING severity", IStatus.ERROR, status.getSeverity()); |
| assertEquals("Status should have deprecated code", IJavaScriptModelStatusConstants.INVALID_INCLUDEPATH, status.getCode()); |
| } finally { |
| VariablesInitializer.reset(); |
| deleteProject("P1"); |
| } |
| } |
| |
| /** |
| * @bug 156226: [model][classpath] Allow classpath variable to be marked as non modifiable |
| * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=156226" |
| */ |
| public void testVariableInitializerReadOnly() throws CoreException { |
| try { |
| // Create initializer |
| String varName = "TEST_READ_ONLY"; |
| String path = "/P1/lib.jar"; |
| VariablesInitializer.setInitializer(new DefaultVariableInitializer(new String[] { varName, path })); |
| assertEquals("JavaScriptCore classpath value should have been initialized", JavaScriptCore.getIncludepathVariable(varName).toString(), path); |
| |
| // verify that Classpath Variable is read-only |
| assertTrue("JavaScriptCore classpath variable should be read-only", JavaScriptCore.isIncludepathVariableReadOnly(varName)); |
| |
| // Create project |
| IJavaScriptProject project = createJavaProject("P1"); |
| createFile("/P1/lib.jar", ""); |
| IIncludePathEntry variable = JavaScriptCore.newVariableEntry(new Path("TEST_READ_ONLY"), null, null); |
| IJavaScriptModelStatus status = JavaScriptConventions.validateClasspathEntry(project, variable, false); |
| assertStatus("OK", status); |
| assertTrue("Status should be OK", status.isOK()); |
| assertEquals("Status should be VERIFIED_OK", JavaModelStatus.VERIFIED_OK, status); |
| } finally { |
| VariablesInitializer.reset(); |
| deleteProject("P1"); |
| } |
| } |
| public void testVariableInitializerDeprecatedAndReadOnly() throws CoreException { |
| try { |
| // Create initializer |
| String varName = "TEST_DEPRECATED_READ_ONLY"; |
| String path = "/P1/lib.jar"; |
| VariablesInitializer.setInitializer(new DefaultVariableInitializer(new String[] { varName, path })); |
| assertEquals("JavaScriptCore classpath value should have been initialized", JavaScriptCore.getIncludepathVariable(varName).toString(), path); |
| |
| // verify that Classpath Variable is read-only |
| assertEquals("JavaScriptCore classpath variable should be deprecated", "A deprecated and read-only initializer", JavaScriptCore.getIncludepathVariableDeprecationMessage(varName)); |
| assertTrue("JavaScriptCore classpath variable should be read-only", JavaScriptCore.isIncludepathVariableReadOnly(varName)); |
| |
| // Create project |
| IJavaScriptProject project = createJavaProject("P1"); |
| createFile("/P1/lib.jar", ""); |
| IIncludePathEntry variable = JavaScriptCore.newVariableEntry(new Path("TEST_DEPRECATED_READ_ONLY"), null, null); |
| IJavaScriptModelStatus status = JavaScriptConventions.validateClasspathEntry(project, variable, false); |
| assertStatus("Classpath variable 'TEST_DEPRECATED_READ_ONLY' in project P1 is deprecated: 'A deprecated and read-only initializer'", status); |
| assertFalse("Status should not be OK", status.isOK()); |
| assertEquals("Status should have WARNING severity", IStatus.WARNING, status.getSeverity()); |
| assertEquals("Status should have deprecated code", IJavaScriptModelStatusConstants.DEPRECATED_VARIABLE, status.getCode()); |
| } finally { |
| VariablesInitializer.reset(); |
| deleteProject("P1"); |
| } |
| } |
| |
| /** |
| * @bug 172207: [model] Marker for deprecated classpath variable should always have WARNING severity |
| * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=172207" |
| */ |
| public void testVariableInitializerBug172207() throws CoreException { |
| try { |
| // Create initializer |
| String varName = "TEST_DEPRECATED_READ_ONLY"; |
| String path = "/P1/lib.jar"; |
| VariablesInitializer.setInitializer(new DefaultVariableInitializer(new String[] { varName, path })); |
| assertEquals("JavaScriptCore classpath value should have been initialized", JavaScriptCore.getIncludepathVariable(varName).toString(), path); |
| |
| // verify that Classpath Variable is read-only |
| assertEquals("JavaScriptCore classpath variable should be deprecated", "A deprecated and read-only initializer", JavaScriptCore.getIncludepathVariableDeprecationMessage(varName)); |
| assertTrue("JavaScriptCore classpath variable should be read-only", JavaScriptCore.isIncludepathVariableReadOnly(varName)); |
| |
| // Create project |
| IJavaScriptProject project = createJavaProject("P1"); |
| createFile("/P1/lib.jar", ""); |
| IIncludePathEntry variable = JavaScriptCore.newVariableEntry(new Path("TEST_DEPRECATED_READ_ONLY"), null, null); |
| IIncludePathEntry[] entries = project.getRawIncludepath(); |
| int length = entries.length; |
| System.arraycopy(entries, 0, entries = new IIncludePathEntry[length+1], 0, length); |
| entries[length] = variable; |
| project.setRawIncludepath(entries, null); |
| |
| // verify markers |
| waitForAutoBuild(); |
| IMarker[] markers = project.getProject().findMarkers(IJavaScriptModelMarker.BUILDPATH_PROBLEM_MARKER, false, IResource.DEPTH_ZERO); |
| sortMarkers(markers); |
| assertMarkers("Unexpected marker(s)", |
| "Classpath variable 'TEST_DEPRECATED_READ_ONLY' in project P1 is deprecated: 'A deprecated and read-only initializer'", |
| markers); |
| assertEquals("Marker on deprecated variable should be a WARNING", IMarker.SEVERITY_WARNING, markers[0].getAttribute(IMarker.SEVERITY, -1)); |
| } finally { |
| VariablesInitializer.reset(); |
| deleteProject("P1"); |
| } |
| } |
| |
| /** |
| * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=61872" |
| */ |
| public void testUserLibraryInitializer1() throws CoreException { |
| try { |
| // Create new user library "SWT" |
| JsGlobalScopeContainerInitializer initializer= JavaScriptCore.getJsGlobalScopeContainerInitializer(JavaScriptCore.USER_LIBRARY_CONTAINER_ID); |
| String libraryName = "SWT"; |
| IPath containerPath = new Path(JavaScriptCore.USER_LIBRARY_CONTAINER_ID); |
| UserLibraryJsGlobalScopeContainer containerSuggestion = new UserLibraryJsGlobalScopeContainer(libraryName); |
| initializer.requestJsGlobalScopeContainerUpdate(containerPath.append(libraryName), null, containerSuggestion); |
| |
| // Create java project |
| createJavaProject("p61872"); |
| IFile jarFile = createFile("/p61872/swt.jar", ""); |
| IFile srcFile = createFile("/p61872/swtsrc.zip", ""); |
| |
| // Modify user library |
| Preferences preferences = JavaScriptCore.getPlugin().getPluginPreferences(); |
| String propertyName = UserLibraryManager.CP_USERLIBRARY_PREFERENCES_PREFIX+"SWT"; |
| StringBuffer propertyValue = new StringBuffer("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<userlibrary systemlibrary=\"false\" version=\"1\">\r\n<archive"); |
| String jarFullPath = getWorkspaceRoot().getLocation().append(jarFile.getFullPath()).toString(); |
| propertyValue.append(" path=\""+jarFullPath); |
| propertyValue.append("\"/>\r\n</userlibrary>\r\n"); |
| preferences.setValue(propertyName, propertyValue.toString()); |
| JavaScriptCore.getPlugin().savePluginPreferences(); |
| |
| // Modify project classpath |
| editFile( |
| "/p61872/.classpath", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + |
| "<classpath>\n" + |
| " <classpathentry kind=\"con\" path=\"org.eclipse.wst.jsdt.USER_LIBRARY/SWT\"/>\n" + |
| " <classpathentry kind=\"output\" path=\"\"/>\n" + |
| "</classpath>" |
| ); |
| |
| // Verify |
| IIncludePathEntry[] entries = getJavaProject("p61872").getResolvedIncludepath(true); |
| assertEquals("Invalid entries number in resolved classpath for project p61872!", 1, entries.length); |
| assertEquals("Invalid path for project 61872 classpath entry!", jarFullPath.toLowerCase(), entries[0].getPath().toString().toLowerCase()); |
| assertNull("Project 61872 classpath entry should not have any source attached!", entries[0].getSourceAttachmentPath()); |
| |
| // Modify user library |
| propertyValue = new StringBuffer("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<userlibrary systemlibrary=\"false\" version=\"1\">\r\n<archive"); |
| String srcFullPath = getWorkspaceRoot().getLocation().append(srcFile.getFullPath()).toString(); |
| propertyValue.append(" sourceattachment=\""+srcFullPath); |
| propertyValue.append("\" path=\""+jarFullPath); |
| propertyValue.append("\"/>\r\n</userlibrary>\r\n"); |
| preferences.setValue(propertyName, propertyValue.toString()); |
| JavaScriptCore.getPlugin().savePluginPreferences(); |
| |
| // Verify |
| entries = getJavaProject("p61872").getResolvedIncludepath(true); |
| assertEquals("Invalid entries number in resolved classpath for project p61872!", 1, entries.length); |
| assertEquals("Invalid path for project 61872 classpath entry!", jarFullPath.toLowerCase(), entries[0].getPath().toString().toLowerCase()); |
| assertEquals("Invalid source attachement path for project 61872 classpath entry!", srcFullPath.toLowerCase(), entries[0].getSourceAttachmentPath().toString().toLowerCase()); |
| } finally { |
| deleteProject("p61872"); |
| } |
| } |
| } |