| /******************************************************************************* |
| * 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.ArrayList; |
| |
| import org.eclipse.core.resources.*; |
| 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.ElementChangedEvent; |
| import org.eclipse.wst.jsdt.core.IIncludePathEntry; |
| import org.eclipse.wst.jsdt.core.IJavaScriptUnit; |
| import org.eclipse.wst.jsdt.core.IElementChangedListener; |
| import org.eclipse.wst.jsdt.core.IJavaScriptElementDelta; |
| import org.eclipse.wst.jsdt.core.IJavaScriptProject; |
| import org.eclipse.wst.jsdt.core.IPackageFragment; |
| import org.eclipse.wst.jsdt.core.JavaScriptCore; |
| import org.eclipse.wst.jsdt.internal.core.*; |
| import org.eclipse.wst.jsdt.core.*; |
| |
| import junit.framework.Test; |
| |
| /** |
| * These test ensure that modifications in Java projects are correctly reported |
| * as IJavaElementDeltas. |
| */ |
| public class JavaElementDeltaTests extends ModifyingResourceTests { |
| |
| public class DeltaListener implements IElementChangedListener { |
| ArrayList deltas; |
| int eventType; |
| |
| public DeltaListener() { |
| DeltaListener.this.deltas = new ArrayList(); |
| DeltaListener.this.eventType = -1; |
| } |
| |
| public DeltaListener(int eventType) { |
| DeltaListener.this.deltas = new ArrayList(); |
| DeltaListener.this.eventType = eventType; |
| } |
| |
| public void elementChanged(ElementChangedEvent event) { |
| if (DeltaListener.this.eventType == -1 |
| || event.getType() == DeltaListener.this.eventType) { |
| DeltaListener.this.deltas.add(event.getDelta()); |
| } |
| } |
| |
| public void flush() { |
| DeltaListener.this.deltas = new ArrayList(); |
| } |
| |
| public String toString() { |
| StringBuffer buffer = new StringBuffer(); |
| for (int i = 0, length = DeltaListener.this.deltas.size(); i < length; i++) { |
| IJavaScriptElementDelta delta = (IJavaScriptElementDelta) this.deltas |
| .get(i); |
| IJavaScriptElementDelta[] children = delta |
| .getAffectedChildren(); |
| if (children.length > 0) { |
| for (int j = 0, childrenLength = children.length; j < childrenLength; j++) { |
| buffer.append(children[j]); |
| if (j != childrenLength - 1) { |
| buffer.append("\n"); |
| } |
| } |
| } else { |
| buffer.append(delta); |
| } |
| if (i != length - 1) { |
| buffer.append("\n\n"); |
| } |
| } |
| return buffer.toString(); |
| } |
| } |
| |
| public static Test suite() { |
| return buildModelTestSuite(JavaElementDeltaTests.class); |
| } |
| |
| // Use this static initializer to specify subset for tests |
| // All specified tests which do not belong to the class are skipped... |
| static { |
| // TESTS_PREFIX = "testBug100772_ProjectScope"; |
| // TESTS_NAMES = new String[] { "testAddInvalidSubfolder" }; |
| // TESTS_NUMBERS = new int[] { 100772 }; |
| // TESTS_RANGE = new int[] { 83304, -1 }; |
| } |
| |
| public JavaElementDeltaTests(String name) { |
| super(name); |
| } |
| |
| /** |
| * Ensures that adding a comment to a working copy and commiting it triggers |
| * an empty fine grained delta with the kind set for POST_CHANGE listeners. |
| * (regression test for bug 32937 Kind not set for empty fine-grained delta) |
| */ |
| public void testAddCommentAndCommit() throws CoreException { |
| DeltaListener listener = new DeltaListener( |
| ElementChangedEvent.POST_CHANGE); |
| IJavaScriptUnit copy = null; |
| try { |
| createJavaProject("P", new String[] { "" }); |
| createFile("P/X.js", "function X() {\n" + "}"); |
| IJavaScriptUnit unit = getCompilationUnit("P", "", "", "X.js"); |
| copy = unit.getWorkingCopy(null); |
| |
| // add comment to working copy |
| copy.getBuffer().setContents( |
| "function X(){\n" + " // some comment\n" + "}"); |
| |
| // commit working copy |
| JavaScriptCore.addElementChangedListener(listener, |
| ElementChangedEvent.POST_CHANGE); |
| copy.commitWorkingCopy(true, null); |
| assertEquals( |
| "Unexpected delta after committing working copy", |
| "P[*]: {CHILDREN}\n" |
| + " <project root>[*]: {CHILDREN}\n" |
| + " <default>[*]: {CHILDREN}\n" |
| + " X.js[*]: {CONTENT | FINE GRAINED | PRIMARY RESOURCE}", |
| listener.toString()); |
| } finally { |
| JavaScriptCore.removeElementChangedListener(listener); |
| if (copy != null) |
| copy.discardWorkingCopy(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Add cu in default package test (proj=src=bin). |
| */ |
| public void testAddCuInDefaultPkg1() throws CoreException { |
| try { |
| createJavaProject("P", new String[] { "" }); |
| startDeltas(); |
| createFile("P/X.js", "function X() {\n" + "}"); |
| assertDeltas("Unexpected delta", "P[*]: {CHILDREN}\n" |
| + " <project root>[*]: {CHILDREN}\n" |
| + " <default>[*]: {CHILDREN}\n" + " X.js[+]: {}"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Add cu in default package test (proj!=src!=bin). |
| */ |
| public void testAddCuInDefaultPkg2() throws CoreException { |
| try { |
| createJavaProject("P", new String[] { "src" }); |
| startDeltas(); |
| createFile("P/src/X.js", "function X() {\n" + "}"); |
| assertDeltas("Unexpected delta", "P[*]: {CHILDREN}\n" |
| + " src[*]: {CHILDREN}\n" + " <default>[*]: {CHILDREN}\n" |
| + " X.js[+]: {}"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Add cu after opening its project (regression test for 56870 copied file |
| * not shown in package explorer / java browser [ccp]) |
| */ |
| public void testAddCuAfterProjectOpen() throws CoreException { |
| try { |
| IJavaScriptProject p1 = createJavaProject("P1", |
| new String[] { "src" }); |
| IJavaScriptProject p2 = createJavaProject("P2", |
| new String[] { "src" }); |
| createFile("P2/src/X.js", "function X() {\n" + "}"); |
| IProject project = p2.getProject(); |
| project.close(null); |
| |
| // invalidate roots |
| p1.setRawIncludepath(new IIncludePathEntry[] {}, null); |
| |
| // open project |
| project.open(null); |
| |
| startDeltas(); |
| createFile("P2/src/Y.js", "function Y() {\n" + "}"); |
| assertDeltas("Unexpected delta", "P2[*]: {CHILDREN}\n" |
| + " src[*]: {CHILDREN}\n" + " <default>[*]: {CHILDREN}\n" |
| + " Y.js[+]: {}"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P1"); |
| deleteProject("P2"); |
| } |
| } |
| |
| /* |
| * Add the .classpath file to a Java project that was missing it. |
| * (regression test for bug 26128 packages don't appear in package explorer |
| * view) |
| */ |
| public void testAddDotClasspathFile() throws CoreException { |
| try { |
| createProject("P"); |
| createFolder("/P/src"); |
| |
| // add Java nature |
| editFile( |
| "/P/.project", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" |
| + "<projectDescription>\n" |
| + " <name>Test</name>\n" |
| + " <comment></comment>\n" |
| + " <projects>\n" |
| + " </projects>\n" |
| + " <buildSpec>\n" |
| + " <buildCommand>\n" |
| + " <name>org.eclipse.wst.jsdt.core.jsbuilder</name>\n" |
| + " <arguments>\n" |
| + " </arguments>\n" |
| + " </buildCommand>\n" |
| + " </buildSpec>\n" |
| + " <natures>\n" |
| + " <nature>org.eclipse.wst.jsdt.core.jsnature</nature>\n" |
| + " </natures>\n" + "</projectDescription>"); |
| |
| startDeltas(); |
| createFile( |
| "P/.classpath", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" |
| + "<classpath>\n" |
| + " <classpathentry kind=\"src\" path=\"src\"/>\n" |
| + " <classpathentry kind=\"output\" path=\"bin\"/>\n" |
| + "</classpath>"); |
| assertDeltas("Unexpected delta", "P[*]: {CHILDREN}\n" |
| + " <project root>[*]: {REMOVED FROM CLASSPATH}\n" |
| + " src[*]: {ADDED TO CLASSPATH}\n" |
| + " ResourceDelta(/P/.classpath)[+]"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Ensure that a resource delta is fired when a file is added to a non-java |
| * project. (regression test for bug 18698 Seeing non-java projects in |
| * package view) |
| */ |
| public void testAddFileToNonJavaProject() throws CoreException { |
| try { |
| createProject("P"); |
| startDeltas(); |
| createFile("/P/toto.txt", ""); |
| assertDeltas("Unexpected delta", "ResourceDelta(/P)"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Ensure that adding a folder in a non-Java folder (i.e. a folder with an |
| * invalid package name) reports the correct delta (regression test for bug |
| * 130982 META-INF directories shown as empty META-INF.* packages in J2EE |
| * Navigator) |
| */ |
| public void testAddFolderInNonJavaFolder() throws CoreException { |
| try { |
| createJavaProject("P"); |
| createFolder("/P/META-INF"); |
| startDeltas(); |
| createFolder("/P/META-INF/folder"); |
| assertDeltas("Unexpected delta", "P[*]: {CONTENT}\n" |
| + " ResourceDelta(/P/META-INF)[*]"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Ensure that a resource delta is fired when a .name folder is added to a |
| * java project where prj=src. (regression test for bug 31383 Strange |
| * rendering of of link resources when link points to Eclipse workspace) |
| */ |
| public void testAddInvalidSubfolder() throws CoreException { |
| try { |
| createJavaProject("P"); |
| startDeltas(); |
| createFolder("/P/p/.folder"); |
| assertDeltas("Unexpected delta", "P[*]: {CHILDREN}\n" |
| + " <project root>[*]: {CHILDREN}\n" + " p[+]: {}"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Add the java nature to an existing project. |
| */ |
| public void testAddJavaNature() throws CoreException { |
| try { |
| createProject("P"); |
| startDeltas(); |
| addJavaNature("P"); |
| assertDeltas("Unexpected delta", "P[+]: {}\n" + "ResourceDelta(/P)"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Add the java nature to an existing project and set the classpath in an |
| * IWorkspaceRunnable. Ensures that adding a non-java resource reports the |
| * correct delta. (regression test for bug 44066 Package Explorer doesn't |
| * show new file) |
| */ |
| public void testAddJavaNatureAndClasspath() throws CoreException { |
| try { |
| createProject("P"); |
| ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| addJavaNature("P"); |
| createFolder("/P/src"); |
| getJavaProject("P").setRawIncludepath( |
| new IIncludePathEntry[] { JavaScriptCore |
| .newSourceEntry(new Path("/P/src")) }, |
| null); |
| } |
| }, null); |
| startDeltas(); |
| createFile("/P/src/file.txt", ""); |
| assertDeltas("Unexpected delta", "P[*]: {CHILDREN}\n" |
| + " src[*]: {CONTENT}\n" |
| + " ResourceDelta(/P/src/file.txt)[+]"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Add a java project. |
| */ |
| public void testAddJavaProject() throws CoreException { |
| try { |
| startDeltas(); |
| createJavaProject("P", new String[] { "" }); |
| assertDeltas("Unexpected delta", "P[+]: {}"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Add a non-java project. |
| */ |
| public void testAddNonJavaProject() throws CoreException { |
| try { |
| startDeltas(); |
| createProject("P"); |
| assertDeltas("Should get a non-Java resource delta", |
| "ResourceDelta(/P)"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| public void testAddPackageSourceIsBin() throws CoreException { |
| try { |
| createJavaProject("P", new String[] { "src" }); |
| startDeltas(); |
| createFolder("P/src/x"); |
| assertDeltas("Unexpected delta", "P[*]: {CHILDREN}\n" |
| + " src[*]: {CHILDREN}\n" + " x[+]: {}"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Add 2 java projects in an IWorkspaceRunnable. |
| */ |
| public void testAddTwoJavaProjects() throws CoreException { |
| try { |
| startDeltas(); |
| ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| createJavaProject("P1", new String[] { "" }); |
| createJavaProject("P2", new String[] { "src" }); |
| } |
| }, null); |
| assertEquals("Unexpected delta", "P1[+]: {}\n" + "P2[+]: {}", |
| getSortedByProjectDeltas()); |
| } finally { |
| stopDeltas(); |
| deleteProject("P1"); |
| deleteProject("P2"); |
| } |
| } |
| |
| /* |
| * Add 2 java projects in an IWorkspaceRunnable. |
| */ |
| public void testAddTwoJavaProjectsWithExtraSetClasspath() |
| throws CoreException { |
| try { |
| startDeltas(); |
| ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| IJavaScriptProject p1 = createJavaProject("P1", |
| new String[] { "" }); |
| // should be a no-op and no extra delta volley should be |
| // fired |
| p1.setRawIncludepath(p1.getRawIncludepath(), null); |
| createJavaProject("P2", new String[] { "src" }); |
| } |
| }, null); |
| assertEquals("Unexpected delta", "P1[+]: {}\n" + "P2[+]: {}", |
| getSortedByProjectDeltas()); |
| } finally { |
| stopDeltas(); |
| deleteProject("P1"); |
| deleteProject("P2"); |
| } |
| } |
| |
| /* |
| * Batch operation test. |
| */ |
| public void testBatchOperation() throws CoreException { |
| try { |
| createJavaProject("P", new String[] { "src" }); |
| createFolder("P/src/x"); |
| createFile("P/src/x/A.js", "function A() {\n" + "}"); |
| startDeltas(); |
| JavaScriptCore.run(new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| IJavaScriptUnit unit = getCompilationUnit("P/src/x/A.js"); |
| // unit.createType("class B {}", null, false, monitor); |
| unit.createField("var i;", null, false, monitor); |
| } |
| }, null); |
| assertDeltas( |
| "Unexpected delta", |
| "P[*]: {CHILDREN}\n" |
| + " src[*]: {CHILDREN}\n" |
| + " x[*]: {CHILDREN}\n" |
| + " A.js[*]: {CHILDREN | FINE GRAINED | PRIMARY RESOURCE}\n" |
| + " i[+]: {}"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Ensures that if a project's output folder is used as a lib folder in |
| * another project, building the first project results in the correct delta |
| * in the other project. |
| */ |
| public void testBuildProjectUsedAsLib() throws CoreException { |
| try { |
| IJavaScriptProject p1 = createJavaProject("P1", |
| new String[] { "src1" }, new String[] { "JCL_LIB" }); |
| createJavaProject("P2", new String[] { "src2" }, |
| new String[] { "/P1/bin1" }); |
| createFile("/P1/src1/X.js", "function X() {\n" + "}"); |
| |
| // force opening of project to avoid external jar delta |
| p1.open(null); |
| |
| startDeltas(); |
| |
| // full build |
| p1.getProject().build(IncrementalProjectBuilder.FULL_BUILD, null); |
| waitForAutoBuild(); |
| assertDeltas("Unexpected delta (1)", "P2[*]: {CHILDREN}\n" |
| + " /P1/bin1[*]: {CHILDREN}\n" |
| + " <default>[*]: {CHILDREN}\n" + " X.class[+]: {}"); |
| |
| editFile("/P1/src1/X.js", "function X() {\n" + |
| // " void foo() {}\n" + |
| "}\n" + "function Y() {\n" + "}"); |
| clearDeltas(); |
| |
| // incremental buid |
| p1.getProject().build(IncrementalProjectBuilder.INCREMENTAL_BUILD, |
| null); |
| waitForAutoBuild(); |
| assertDeltas("Unexpected delta (2)", "P2[*]: {CHILDREN}\n" |
| + " /P1/bin1[*]: {CHILDREN}\n" |
| + " <default>[*]: {CHILDREN}\n" |
| + " X.class[*]: {CONTENT}\n" + " Y.class[+]: {}"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P1"); |
| deleteProject("P2"); |
| } |
| } |
| |
| /** |
| * Ensures that changing the custom output folder of a source entry triggers |
| * a F_REMOVED_FROM_CLASSPATH and F_ADDED_TO_CLASSPATH delta. |
| */ |
| public void testChangeCustomOutput() throws CoreException { |
| try { |
| IJavaScriptProject proj = createJavaProject("P", |
| new String[] { "src" }, "bin", new String[] { "bin1" }); |
| startDeltas(); |
| setClasspath(proj, new IIncludePathEntry[] { JavaScriptCore |
| .newSourceEntry(new Path("/P/src"), new IPath[0], new Path( |
| "/P/bin2")) }); |
| assertDeltas( |
| "Unexpected delta", |
| "P[*]: {CHILDREN | CLASSPATH CHANGED}\n" |
| + " src[*]: {ADDED TO CLASSPATH | REMOVED FROM CLASSPATH}\n" |
| + " ResourceDelta(/P/.classpath)[*]"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| // |
| // /* |
| // * Ensures that the setting the classpath where the only change is the |
| // export flag |
| // * triggers a F_CLASSPATH CHANGED delta. |
| // * (regression test for bug 75517 No classpath delta for project becoming |
| // exported) |
| // */ |
| // public void testChangeExportFlag() throws CoreException { |
| // try { |
| // createJavaProject("P1"); |
| // IJavaScriptProject proj = createJavaProject("P2", new String[] {}, new |
| // String[] {}, new String[] {"/P1"}, new boolean[] {false}, "bin"); |
| // startDeltas(); |
| // setClasspath( |
| // proj, |
| // new IIncludePathEntry[] { |
| // JavaScriptCore.newProjectEntry(new Path("/P1"), true) |
| // }); |
| // assertDeltas( |
| // "Unexpected delta", |
| // "P2[*]: {CONTENT | CLASSPATH CHANGED}\n" + |
| // " ResourceDelta(/P2/.classpath)[*]" |
| // ); |
| // } finally { |
| // stopDeltas(); |
| // deleteProject("P1"); |
| // deleteProject("P2"); |
| // } |
| // } |
| |
| /** |
| * Ensures that the setting the classpath with a library entry triggers a |
| * F_REMOVED_FROM_CLASSPATH and F_ADDED_TO_CLASSPATH delta. |
| */ |
| public void testChangeRootKind() throws CoreException { |
| try { |
| IJavaScriptProject proj = createJavaProject("P", |
| new String[] { "src" }); |
| startDeltas(); |
| setClasspath(proj, new IIncludePathEntry[] { JavaScriptCore |
| .newLibraryEntry(new Path("/P/src"), null, null, false) }); |
| assertDeltas( |
| "Unexpected delta", |
| "P[*]: {CHILDREN | CLASSPATH CHANGED}\n" |
| + " src[*]: {ADDED TO CLASSPATH | REMOVED FROM CLASSPATH}\n" |
| + " ResourceDelta(/P/.classpath)[*]"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Close a java project. |
| */ |
| public void testCloseJavaProject() throws CoreException { |
| try { |
| createJavaProject("P", new String[] { "" }); |
| IProject project = getProject("P"); |
| startDeltas(); |
| project.close(null); |
| assertDeltas("Unexpected delta", "P[*]: {CLOSED}\n" |
| + "ResourceDelta(/P)"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Close a non-java project. |
| */ |
| public void testCloseNonJavaProject() throws CoreException { |
| try { |
| createProject("P"); |
| IProject project = getProject("P"); |
| startDeltas(); |
| project.close(null); |
| assertDeltas("Unexpected delta", "ResourceDelta(/P)"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| // /* |
| // * Closing a non-java project that contains a jar referenced in another |
| // project should produce |
| // * a delta on this other project. |
| // * (regression test for bug 19058 Closing non-java project doesn't remove |
| // root from java project) |
| // */ |
| // public void testCloseNonJavaProjectUpdateDependent() throws CoreException |
| // { |
| // try { |
| // createProject("SP"); |
| // createFile("/SP/x.jar", ""); |
| // createJavaProject("JP", new String[] {""}, new String[] {"/SP/x.jar"}, |
| // ""); |
| // IProject project = getProject("SP"); |
| // startDeltas(); |
| // project.close(null); |
| // assertDeltas( |
| // "Unexpected delta", |
| // "JP[*]: {CHILDREN}\n" + |
| // " /SP/x.jar[-]: {}\n" + |
| // "ResourceDelta(/SP)" |
| // ); |
| // } finally { |
| // stopDeltas(); |
| // deleteProject("SP"); |
| // deleteProject("JP"); |
| // } |
| // } |
| /** |
| * Test that deltas are generated when a compilation unit is added and |
| * removed from a package via core API. |
| */ |
| public void testCompilationUnitRemoveAndAdd() throws CoreException { |
| try { |
| createJavaProject("P"); |
| // createFolder("/P/p"); |
| IFile file = createFile("/P/X.js", "function X() {\n" + "}"); |
| |
| // delete cu |
| startDeltas(); |
| deleteResource(file); |
| assertDeltas("Unexpected delta after deleting /P/X.js", |
| "P[*]: {CHILDREN}\n" + " <project root>[*]: {CHILDREN}\n" |
| + " <default>[*]: {CHILDREN}\n" + " X.js[-]: {}"); |
| |
| // add cu |
| clearDeltas(); |
| createFile("/P/X.js", "function X() {\n" + "}"); |
| assertDeltas("Unexpected delta after adding /P/p/X.js", |
| "P[*]: {CHILDREN}\n" + " <project root>[*]: {CHILDREN}\n" |
| + " p[*]: {CHILDREN}\n" + " X.js[+]: {}"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| public void testCreateSharedWorkingCopy() throws CoreException { |
| IJavaScriptUnit copy = null; |
| try { |
| createJavaProject("P", new String[] { "" }); |
| createFile("P/X.js", "function X() {\n" + "}"); |
| IJavaScriptUnit unit = getCompilationUnit("P", "", "", "X.js"); |
| startDeltas(); |
| copy = unit.getWorkingCopy(new WorkingCopyOwner() { |
| }, null); |
| assertDeltas("Unexpected delta", "P[*]: {CHILDREN}\n" |
| + " <project root>[*]: {CHILDREN}\n" |
| + " <default>[*]: {CHILDREN}\n" |
| + " [Working copy] X.js[+]: {}"); |
| } finally { |
| stopDeltas(); |
| if (copy != null) |
| copy.discardWorkingCopy(); |
| deleteProject("P"); |
| } |
| } |
| |
| public void testCreateWorkingCopy() throws CoreException { |
| IJavaScriptUnit copy = null; |
| try { |
| createJavaProject("P", new String[] { "" }); |
| createFile("P/X.js", "function X() {\n" + "}"); |
| IJavaScriptUnit unit = getCompilationUnit("P", "", "", "X.js"); |
| startDeltas(); |
| copy = unit.getWorkingCopy(null); |
| assertDeltas("Unexpected delta", "P[*]: {CHILDREN}\n" |
| + " <project root>[*]: {CHILDREN}\n" |
| + " <default>[*]: {CHILDREN}\n" |
| + " [Working copy] X.js[+]: {}"); |
| } finally { |
| stopDeltas(); |
| if (copy != null) |
| copy.discardWorkingCopy(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Ensure that the delta is correct if a package is copied on top of an |
| * existing package. (regression test for bug 61270 Wrong delta when copying |
| * a package that overrides another package) |
| */ |
| public void testCopyAndOverwritePackage() throws CoreException { |
| try { |
| createJavaProject("P", new String[] { "src1", "src2" }); |
| // createFolder("/P/src1/p"); |
| createFile("P/src1/X.js", "function X() {\n" + "}"); |
| createFolder("/P/src2"); |
| startDeltas(); |
| getPackage("/P/src1").copy(getPackageFragmentRoot("/P/src2"), |
| null/* no sibling */, null/* no rename */, true/* replace */, |
| null/* no progress */); |
| assertDeltas("Unexpected delta", "P[*]: {CHILDREN}\n" |
| + " src2[*]: {CHILDREN}\n" + " p[*]: {CHILDREN}\n" |
| + " X.js[+]: {}"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /** |
| * Test that deltas are generated when a compilation unit not on the |
| * classpath is added and removed from a package via core API. |
| */ |
| public void testCUNotOnClasspath() throws CoreException { |
| try { |
| createJavaProject("P", new String[] {}); |
| // createFolder("/P/src/p"); |
| IFile file = createFile("/P/src/p/X.js", "function X() {\n" + "}"); |
| |
| startDeltas(); |
| deleteResource(file); |
| assertDeltas("Unexpected delta after deletion of /P/src/X.js", |
| "P[*]: {CONTENT}\n" + " ResourceDelta(/P/src)[*]"); |
| |
| clearDeltas(); |
| createFile("/P/src/X.js", "function X() {\n" + "}"); |
| assertDeltas("Unexpected delta after addition of /P/src/X.js", |
| "P[*]: {CONTENT}\n" + " ResourceDelta(/P/src)[*]"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| // /* |
| // * Ensure that deleting a jar that is in a folder and that is on the |
| // classpath reports |
| // * a removed pkg fragment root delta. |
| // * (regression test for bug 27068 Elements in the Package Explorer are |
| // displayed but don't more exist [package explorer]) |
| // * |
| // */ |
| // public void testDeleteInnerJar() throws CoreException { |
| // try { |
| // createJavaProject("P", new String[] {"src"}, new String[] |
| // {"/P/lib/x.jar"}, "bin"); |
| // createFolder("/P/lib"); |
| // IFile file = createFile("/P/lib/x.jar", ""); |
| // startDeltas(); |
| // deleteResource(file); |
| // assertDeltas( |
| // "Unexpected deltas", |
| // "P[*]: {CHILDREN | CONTENT}\n" + |
| // " lib/x.jar[-]: {}\n" + |
| // " ResourceDelta(/P/lib)[*]" |
| // ); |
| // } finally { |
| // stopDeltas(); |
| // deleteProject("P"); |
| // } |
| // } |
| /* |
| * Ensure that deleting a non-Java folder that contains a source root folder |
| * reports a removed root delta as well as a resource delta for the removed |
| * folder. (regression test for bug 24045 Error deleting parent folder of |
| * source folder) |
| */ |
| public void testDeleteNonJavaFolder() throws CoreException { |
| try { |
| createJavaProject("P", new String[] { "foo/bar" }); |
| IFolder folder = getFolder("/P/foo"); |
| startDeltas(); |
| deleteResource(folder); |
| assertDeltas("Unexpected deltas", "P[*]: {CHILDREN | CONTENT}\n" |
| + " foo/bar[-]: {}\n" + " ResourceDelta(/P/foo)[-]"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Ensures that changing a project's classpath and deleting it in an |
| * IWorkspaceRunnable doesn't throw an NPE (regression test for bug 148015 |
| * NPE in log from ClasspathChange) |
| */ |
| public void testDeleteProjectAfterChangingClasspath() throws CoreException { |
| try { |
| final IJavaScriptProject project = createJavaProject("P"); |
| IWorkspaceRunnable runnable = new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| project.setRawIncludepath(createClasspath("P", |
| new String[] { "/P/src", "" }), |
| monitor); |
| deleteProject("P"); |
| } |
| }; |
| startDeltas(); |
| getWorkspace().run(runnable, null/* no progress */); |
| assertDeltas("Unexpected delta", "P[-]: {}"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| }/* |
| * Ensure that deleting a project and setting the classpath on another |
| * project in an IWorkspaceRunnable doesn't throw a NullPointerException |
| * (regression test for bug 25197 NPE importing external plugins) |
| */ |
| |
| public void testDeleteProjectSetCPAnotherProject() throws CoreException { |
| final IJavaScriptProject project = createJavaProject("P1", |
| new String[] { "src" }); |
| createJavaProject("P2", new String[] {}); |
| |
| try { |
| startDeltas(); |
| JavaScriptCore.run(new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| deleteProject("P2"); |
| project.setRawIncludepath( |
| new IIncludePathEntry[] { JavaScriptCore |
| .newSourceEntry(project.getPath()) }, null); |
| } |
| }, null); |
| assertDeltas("Unexpected deltas", |
| "P1[*]: {CHILDREN | CLASSPATH CHANGED}\n" |
| + " <project root>[*]: {ADDED TO CLASSPATH}\n" |
| + " src[*]: {REMOVED FROM CLASSPATH}\n" |
| + " ResourceDelta(/P1/.classpath)[*]\n" |
| + "P2[-]: {}"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P1"); |
| deleteProject("P2"); |
| } |
| } |
| |
| public void testDiscardWorkingCopy1() throws CoreException { // renamed from |
| // testDestroyWorkingCopy |
| IJavaScriptUnit copy = null; |
| try { |
| createJavaProject("P", new String[] { "" }); |
| createFile("P/X.js", "public class X {\n" + "}"); |
| IJavaScriptUnit unit = getCompilationUnit("P", "", "", "X.js"); |
| copy = unit.getWorkingCopy(null); |
| startDeltas(); |
| copy.discardWorkingCopy(); |
| assertDeltas("Unexpected delta", "P[*]: {CHILDREN}\n" |
| + " <project root>[*]: {CHILDREN}\n" |
| + " <default>[*]: {CHILDREN}\n" |
| + " [Working copy] X.js[-]: {}"); |
| } finally { |
| stopDeltas(); |
| if (copy != null) |
| copy.discardWorkingCopy(); |
| deleteProject("P"); |
| } |
| } |
| |
| public void testDiscardWorkingCopy2() throws CoreException { // renamed from |
| // testDestroySharedWorkingCopy |
| IJavaScriptUnit copy = null; |
| try { |
| createJavaProject("P", new String[] { "" }); |
| createFile("P/X.js", "public class X {\n" + "}"); |
| IJavaScriptUnit unit = getCompilationUnit("P", "", "", "X.js"); |
| copy = unit.getWorkingCopy(new WorkingCopyOwner() { |
| }, null); |
| startDeltas(); |
| copy.discardWorkingCopy(); |
| assertDeltas("Unexpected delta", "P[*]: {CHILDREN}\n" |
| + " <project root>[*]: {CHILDREN}\n" |
| + " <default>[*]: {CHILDREN}\n" |
| + " [Working copy] X.js[-]: {}"); |
| } finally { |
| stopDeltas(); |
| if (copy != null) |
| copy.discardWorkingCopy(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Ensures that a delta listener that asks for POST_CHANGE events gets those |
| * events and no others. |
| */ |
| public void testListenerPostChange() throws CoreException { |
| DeltaListener listener = new DeltaListener( |
| ElementChangedEvent.POST_CHANGE); |
| IJavaScriptUnit wc = null; |
| try { |
| createJavaProject("P", new String[] { "" }); |
| JavaScriptCore.addElementChangedListener(listener, |
| ElementChangedEvent.POST_CHANGE); |
| |
| // cu creation |
| IPackageFragment pkg = getPackage("P"); |
| IJavaScriptUnit cu = pkg.createCompilationUnit("X.js", |
| "public class X {\n" + "}", false, null); |
| assertEquals( |
| "Unexpected delta after creating CU", |
| "P[*]: {CHILDREN}\n" + " <project root>[*]: {CHILDREN}\n" |
| + " <default>[*]: {CHILDREN}\n" + " X.js[+]: {}", |
| listener.toString()); |
| listener.flush(); |
| |
| // type creation |
| cu.createType("class A {\n" + "}", cu.getType("X"), false, null); |
| assertEquals( |
| "Unexpected delta after creating type", |
| "P[*]: {CHILDREN}\n" |
| + " <project root>[*]: {CHILDREN}\n" |
| + " <default>[*]: {CHILDREN}\n" |
| + " X.js[*]: {CHILDREN | FINE GRAINED | PRIMARY RESOURCE}\n" |
| + " A[+]: {}", listener.toString()); |
| listener.flush(); |
| |
| // non-java resource creation |
| createFile("P/readme.txt", ""); |
| assertEquals("Unexpected delta after creating non-java resource", |
| "P[*]: {CONTENT}\n" + " ResourceDelta(/P/readme.txt)[+]", |
| listener.toString()); |
| listener.flush(); |
| |
| // shared working copy creation |
| wc = cu.getWorkingCopy(new WorkingCopyOwner() { |
| }, null); |
| assertEquals("Unexpected delta after creating shared working copy", |
| "P[*]: {CHILDREN}\n" + " <project root>[*]: {CHILDREN}\n" |
| + " <default>[*]: {CHILDREN}\n" |
| + " [Working copy] X.js[+]: {}", listener |
| .toString()); |
| listener.flush(); |
| |
| // reconcile |
| wc.getBuffer().setContents( |
| "public class X {\n" + " public void foo() {\n" + " }\n" |
| + "}"); |
| wc.reconcile(IJavaScriptUnit.NO_AST, false, null, null); |
| assertEquals("Unexpected delta after reconciling working copy", "", |
| listener.toString()); |
| listener.flush(); |
| |
| // commit |
| wc.commitWorkingCopy(false, null); |
| assertEquals( |
| "Unexpected delta after committing working copy", |
| "P[*]: {CHILDREN}\n" |
| + " <project root>[*]: {CHILDREN}\n" |
| + " <default>[*]: {CHILDREN}\n" |
| + " X.js[*]: {CHILDREN | FINE GRAINED | PRIMARY RESOURCE}\n" |
| + " X[*]: {CHILDREN | FINE GRAINED}\n" |
| + " foo()[+]: {}\n" + " A[-]: {}", listener |
| .toString()); |
| listener.flush(); |
| |
| // shared working copy destruction |
| wc.discardWorkingCopy(); |
| assertEquals( |
| "Unexpected delta after destroying shared working copy", |
| "P[*]: {CHILDREN}\n" + " <project root>[*]: {CHILDREN}\n" |
| + " <default>[*]: {CHILDREN}\n" |
| + " [Working copy] X.js[-]: {}", listener |
| .toString()); |
| listener.flush(); |
| wc = null; |
| |
| } finally { |
| if (wc != null) |
| wc.discardWorkingCopy(); |
| JavaScriptCore.removeElementChangedListener(listener); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Ensures that a delta listener that asks for POST_RECONCILE events gets |
| * those events and no others. |
| */ |
| public void testListenerReconcile() throws CoreException { |
| DeltaListener listener = new DeltaListener( |
| ElementChangedEvent.POST_RECONCILE); |
| IJavaScriptUnit wc = null; |
| try { |
| createJavaProject("P", new String[] { "" }); |
| JavaScriptCore.addElementChangedListener(listener, |
| ElementChangedEvent.POST_RECONCILE); |
| |
| // cu creation |
| IPackageFragment pkg = getPackage("P"); |
| IJavaScriptUnit cu = pkg.createCompilationUnit("X.js", |
| "public class X {\n" + "}", false, null); |
| assertEquals("Unexpected delta after creating CU", "", listener |
| .toString()); |
| listener.flush(); |
| |
| // type creation |
| cu.createType("class A {\n" + "}", cu.getType("X"), false, null); |
| assertEquals("Unexpected delta after creating type", "", listener |
| .toString()); |
| listener.flush(); |
| |
| // non-java resource creation |
| createFile("P/readme.txt", ""); |
| assertEquals("Unexpected delta after creating non-java resource", |
| "", listener.toString()); |
| listener.flush(); |
| |
| // shared working copy creation |
| wc = cu.getWorkingCopy(new WorkingCopyOwner() { |
| }, null); |
| assertEquals("Unexpected delta after creating shared working copy", |
| "", listener.toString()); |
| listener.flush(); |
| |
| // reconcile |
| wc.getBuffer().setContents( |
| "public class X {\n" + " public void foo() {\n" + " }\n" |
| + "}"); |
| wc.reconcile(IJavaScriptUnit.NO_AST, false, null, null); |
| assertEquals("Unexpected delta after reconciling working copy", |
| "X[*]: {CHILDREN | FINE GRAINED}\n" + " foo()[+]: {}\n" |
| + "A[-]: {}", listener.toString()); |
| listener.flush(); |
| |
| // commit |
| wc.commitWorkingCopy(false, null); |
| assertEquals("Unexpected delta after committing working copy", "", |
| listener.toString()); |
| listener.flush(); |
| |
| // shared working copy destruction |
| wc.discardWorkingCopy(); |
| assertEquals( |
| "Unexpected delta after destroying shared working copy", |
| "", listener.toString()); |
| listener.flush(); |
| wc = null; |
| |
| } finally { |
| if (wc != null) |
| wc.discardWorkingCopy(); |
| JavaScriptCore.removeElementChangedListener(listener); |
| deleteProject("P"); |
| } |
| } |
| |
| /** |
| * Ensures that merging a java delta with another one that contains a |
| * resource delta results in a java delta with the resource delta. |
| * (regression test for 11210 ResourceDeltas are lost when merging deltas) |
| */ |
| public void testMergeResourceDeltas() throws CoreException { |
| try { |
| createJavaProject("P", new String[] { "" }); |
| startDeltas(); |
| ResourcesPlugin.getWorkspace().run(new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| // an operation that creates a java delta without firing it |
| IPackageFragment pkg = getPackageFragment("P", "", ""); |
| pkg.createCompilationUnit("X.js", "public class X {\n" |
| + "}", true, null); |
| |
| // an operation that generates a non java resource delta |
| createFile("P/Y.txt", ""); |
| } |
| }, null); |
| assertDeltas("Unexpected delta", "P[*]: {CHILDREN}\n" |
| + " <project root>[*]: {CHILDREN}\n" |
| + " <default>[*]: {CHILDREN}\n" + " X.js[+]: {}\n" |
| + " ResourceDelta(/P/Y.txt)[+]"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| |
| } |
| |
| public void testModifyMethodBodyAndSave() throws CoreException { |
| IJavaScriptUnit workingCopy = null; |
| try { |
| createJavaProject("P", new String[] { "" }); |
| createFolder("P/x/y"); |
| createFile("P/x/y/A.js", "package x.y;\n" + "public class A {\n" |
| + " public void foo() {\n" + " }\n" + "}"); |
| IJavaScriptUnit cu = getCompilationUnit("P/x/y/A.js"); |
| workingCopy = cu.getWorkingCopy(null); |
| workingCopy.getBuffer().setContents( |
| "package x.y;\n" + "public class A {\n" |
| + " public void foo() {\n" |
| + " // method body change \n" + " }\n" + "}"); |
| |
| startDeltas(); |
| workingCopy.commitWorkingCopy(true, null); |
| assertDeltas("Unexpected delta", "P[*]: {CHILDREN}\n" |
| + " <project root>[*]: {CHILDREN}\n" |
| + " x.y[*]: {CHILDREN}\n" |
| + " A.js[*]: {CONTENT | FINE GRAINED | PRIMARY RESOURCE}"); |
| } finally { |
| stopDeltas(); |
| if (workingCopy != null) { |
| workingCopy.discardWorkingCopy(); |
| } |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Ensures that modifying the project output location (i.e. simulate a |
| * build) doesn't report any delta. |
| */ |
| public void testModifyOutputLocation1() throws CoreException { |
| try { |
| createJavaProject("P", new String[] { "src" }); |
| |
| startDeltas(); |
| createFile("/P/bin/X.class", ""); |
| assertDeltas("Unexpected delta", ""); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Ensures that modifying a custom output location (i.e. simulate a build) |
| * doesn't report any delta. (regression test for bug 27494 Source folder |
| * output folder shown in Package explorer) |
| */ |
| public void testModifyOutputLocation2() throws CoreException { |
| try { |
| createJavaProject("P", new String[] { "src" }, "bin1", |
| new String[] { "bin2" }); |
| |
| startDeltas(); |
| createFile("/P/bin2/X.class", ""); |
| assertDeltas("Unexpected delta", ""); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Ensures that modifying a custom output location (i.e. simulate a build) |
| * doesn't report any delta. (regression test for bug 27494 Source folder |
| * output folder shown in Package explorer) |
| */ |
| public void testModifyOutputLocation3() throws CoreException { |
| try { |
| createJavaProject("P", new String[] { "src1", "src2" }, "bin", |
| new String[] { "src1", null }); |
| |
| startDeltas(); |
| createFile("/P/bin/X.class", ""); |
| assertDeltas("Unexpected delta", ""); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Ensures that modifying a custom output location (i.e. simulate a build) |
| * doesn't report any delta. (regression test for bug 32629 DeltaProcessor |
| * walking some binary output) |
| */ |
| public void testModifyOutputLocation4() throws CoreException { |
| try { |
| createJavaProject("P"); |
| editFile( |
| "/P/.classpath", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" |
| + "<classpath>\n" |
| + " <classpathentry excluding=\"src/\" kind=\"src\" output=\"bin1\" path=\"\"/>\n" |
| + " <classpathentry kind=\"src\" output=\"bin2\" path=\"src\"/>\n" |
| + " <classpathentry kind=\"output\" path=\"bin\"/>\n" |
| + "</classpath>"); |
| createFolder("/P/bin2"); |
| |
| startDeltas(); |
| createFile("/P/bin2/X.class", ""); |
| assertDeltas("Unexpected delta", ""); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /** |
| * bug 18953 |
| */ |
| public void testModifyProjectDescriptionAndRemoveFolder() |
| throws CoreException { |
| try { |
| IJavaScriptProject project = createJavaProject("P"); |
| final IProject projectFolder = project.getProject(); |
| final IFolder folder = createFolder("/P/folder"); |
| |
| startDeltas(); |
| getWorkspace().run(new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| IProjectDescription desc = projectFolder.getDescription(); |
| desc.setComment("A comment"); |
| projectFolder.setDescription(desc, null); |
| deleteResource(folder); |
| } |
| }, null); |
| |
| assertDeltas("Unexpected delta", "P[*]: {CHILDREN | CONTENT}\n" |
| + " <project root>[*]: {CHILDREN}\n" + " folder[-]: {}\n" |
| + " ResourceDelta(/P/.project)[*]"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Move a cu from a package to its enclosing package. (regression test for |
| * bug 7033 Stale packages view after moving compilation units) |
| */ |
| public void testMoveCuInEnclosingPkg() throws CoreException { |
| try { |
| createJavaProject("P", new String[] { "" }); |
| createFolder("P/x/y"); |
| createFile("P/x/y/A.js", "package x.y;\n" + "public class A {\n" |
| + "}"); |
| IJavaScriptUnit cu = getCompilationUnit("P/x/y/A.js"); |
| IPackageFragment pkg = getPackage("P/x"); |
| |
| startDeltas(); |
| cu.move(pkg, null, null, true, null); |
| assertDeltas( |
| "Unexpected delta", |
| "P[*]: {CHILDREN}\n" |
| + " <project root>[*]: {CHILDREN}\n" |
| + " x[*]: {CHILDREN}\n" |
| + " A.js[+]: {MOVED_FROM(A.js [in x.y [in <project root> [in P]]])}" |
| + " x.y[*]: {CHILDREN}\n" |
| + " A.js[-]: {MOVED_TO(A.js [in x [in <project root> [in P]]])}\n"); |
| assertElementDescendants("Unexpected children for package x", "x\n" |
| + " A.js\n" + " package x\n" + " class A", pkg); |
| assertElementDescendants("Unexpected children for package x.y", |
| "x.y", getPackage("P/x/y")); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Move a non-java resources that is under a dot-named folder. (regression |
| * test for bug 6687 Wrong JavaModel refresh after drag and drop outside |
| * folder with dot in name) |
| */ |
| public void testMoveResInDotNamedFolder() throws CoreException { |
| try { |
| createJavaProject("P", new String[] {}); |
| IProject project = getProject("P"); |
| createFolder("P/x.y"); |
| IFile file = createFile("P/x.y/test.txt", ""); |
| |
| startDeltas(); |
| file.move(project.getFullPath().append("test.txt"), true, null); |
| assertDeltas("Unexpected delta", "P[*]: {CONTENT}\n" |
| + " ResourceDelta(/P/test.txt)[+]\n" |
| + " ResourceDelta(/P/x.y)[*]"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Move 2 non-java resources that were outside classpath to a package |
| * fragment root. (regression test for bug 28583 Missing one unit in package |
| * view) |
| */ |
| public void testMoveTwoResInRoot() throws CoreException { |
| try { |
| createJavaProject("P", new String[] { "src" }); |
| final IFile f1 = createFile("P/X.js", "public class X {}"); |
| final IFile f2 = createFile("P/Y.js", "public class Y {}"); |
| |
| startDeltas(); |
| JavaScriptCore.run(new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| f1.move(new Path("/P/src/X.js"), true, null); |
| f2.move(new Path("/P/src/Y.js"), true, null); |
| } |
| }, null); |
| assertDeltas("Unexpected delta", "P[*]: {CHILDREN | CONTENT}\n" |
| + " src[*]: {CHILDREN}\n" + " <default>[*]: {CHILDREN}\n" |
| + " X.js[+]: {}\n" + " Y.js[+]: {}\n" |
| + " ResourceDelta(/P/X.js)[-]\n" |
| + " ResourceDelta(/P/Y.js)[-]"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /** |
| * Test that deltas are generated when a nested package fragment root is |
| * removed and added via core API. |
| */ |
| public void testNestedRootParentMove() throws CoreException { |
| try { |
| createJavaProject("P", |
| new String[] { "nested2/src", "nested/src" }); |
| deleteFolder("/P/nested2/src"); |
| |
| startDeltas(); |
| IFolder folder = getFolder("/P/nested/src"); |
| folder.move(new Path("/P/nested2/src"), false, null); |
| assertDeltas("Unexpected delta", "P[*]: {CHILDREN | CONTENT}\n" |
| + " nested2/src[+]: {MOVED_FROM(nested/src [in P])}\n" |
| + " nested/src[-]: {MOVED_TO(nested2/src [in P])}\n" |
| + " ResourceDelta(/P/nested)[*]\n" |
| + " ResourceDelta(/P/nested2)[*]"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /** |
| * Test that deltas are generated when a non-java file is removed and added |
| */ |
| public void testNonJavaResourceRemoveAndAdd() throws CoreException { |
| try { |
| createJavaProject("P", new String[] { "src" }); |
| IFile file = createFile("/P/src/read.txt", ""); |
| |
| startDeltas(); |
| deleteResource(file); |
| assertDeltas("Unexpected delta after deleting /P/src/read.txt", |
| "P[*]: {CHILDREN}\n" + " src[*]: {CONTENT}\n" |
| + " ResourceDelta(/P/src/read.txt)[-]"); |
| |
| clearDeltas(); |
| createFile("/P/src/read.txt", ""); |
| assertDeltas("Unexpected delta after creating /P/src/read.txt", |
| "P[*]: {CHILDREN}\n" + " src[*]: {CONTENT}\n" |
| + " ResourceDelta(/P/src/read.txt)[+]"); |
| |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Open a java project. |
| */ |
| public void testOpenJavaProject() throws CoreException { |
| try { |
| createJavaProject("P", new String[] { "" }); |
| IProject project = getProject("P"); |
| project.close(null); |
| startDeltas(); |
| project.open(null); |
| assertDeltas("Unexpected delta", "P[*]: {OPENED}\n" |
| + "ResourceDelta(/P)"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Open a non-java project. |
| */ |
| public void testOpenNonJavaProject() throws CoreException { |
| try { |
| createProject("P"); |
| IProject project = getProject("P"); |
| project.close(null); |
| startDeltas(); |
| project.open(null); |
| assertDeltas("Unexpected delta", "ResourceDelta(/P)"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /** |
| * Ensures that .classpath overwrite is taken into account. (regression test |
| * for bug 21420 Changing .classpath doesn't update JDT) |
| */ |
| public void testOverwriteClasspath() throws CoreException { |
| try { |
| createJavaProject("P", new String[] { "" }); |
| createFolder("P/src"); |
| createFolder("P/bin"); |
| final IFile newCP = createFile( |
| "P/.classpath2", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" |
| + "<classpath>\n" |
| + " <classpathentry kind=\"src\" path=\"src\"/>\n" |
| + " <classpathentry kind=\"output\" path=\"bin\"/>\n" |
| + "</classpath>"); |
| startDeltas(); |
| IWorkspaceRunnable run = new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| IFile oldCP = newCP.getParent().getFile( |
| new Path(".classpath")); |
| deleteResource(oldCP); |
| newCP.move(new Path("/P/.classpath"), true, null); |
| } |
| }; |
| getWorkspace().run(run, null); |
| assertDeltas("Unexpected delta", "P[*]: {CHILDREN}\n" |
| + " <project root>[*]: {REMOVED FROM CLASSPATH}\n" |
| + " src[*]: {ADDED TO CLASSPATH}\n" |
| + " ResourceDelta(/P/.classpath)[*]\n" |
| + " ResourceDelta(/P/.classpath2)[-]"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /** |
| * Test that deltas are generated when package fragments are added and |
| * removed from a root via core API. |
| */ |
| public void testPackageFragmentAddAndRemove() throws CoreException { |
| try { |
| createJavaProject("P", new String[] { "src" }); |
| |
| startDeltas(); |
| IFolder folder = createFolder("/P/src/p"); |
| assertDeltas("Unexpected delta", "P[*]: {CHILDREN}\n" |
| + " src[*]: {CHILDREN}\n" + " p[+]: {}"); |
| |
| clearDeltas(); |
| deleteResource(folder); |
| assertDeltas("Unexpected delta", "P[*]: {CHILDREN}\n" |
| + " src[*]: {CHILDREN}\n" + " p[-]: {}"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /** |
| * Test that deltas are generated when a package fragment is moved via core |
| * API. |
| */ |
| public void testPackageFragmentMove() throws CoreException { |
| try { |
| createJavaProject("P", new String[] { "src" }); |
| IFolder folder = createFolder("/P/src/p"); |
| |
| startDeltas(); |
| folder.move(new Path("/P/src/p2"), false, null); |
| assertDeltas("Unexpected delta", "P[*]: {CHILDREN}\n" |
| + " src[*]: {CHILDREN}\n" |
| + " p[-]: {MOVED_TO(p2 [in src [in P]])}\n" |
| + " p2[+]: {MOVED_FROM(p [in src [in P]])}"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /** |
| * Test that deltas are generated when a package fragment root is removed |
| * and added via core API. |
| */ |
| public void testPackageFragmentRootRemoveAndAdd() throws CoreException { |
| try { |
| createJavaProject("P", new String[] { "src" }); |
| |
| startDeltas(); |
| deleteFolder("/P/src"); |
| assertDeltas("Unexpected delta after deleting /P/src", |
| "P[*]: {CHILDREN}\n" + " src[-]: {}"); |
| |
| clearDeltas(); |
| createFolder("/P/src"); |
| assertDeltas("Unexpected delta after creating /P/src", |
| "P[*]: {CHILDREN}\n" + " src[+]: {}"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Remove then add a binary project (in a workspace runnable). (regression |
| * test for 24775 Wrong delta when replacing binary project with source |
| * project) |
| */ |
| public void testRemoveAddBinaryProject() throws CoreException { |
| try { |
| IJavaScriptProject project = createJavaProject("P", |
| new String[] { "" }); |
| createFile("P/lib.jar", ""); |
| project.setRawIncludepath(new IIncludePathEntry[] { JavaScriptCore |
| .newLibraryEntry(new Path("/P/lib.jar"), null, null) }, |
| null); |
| |
| startDeltas(); |
| getWorkspace().run(new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| deleteProject("P"); |
| createJavaProject("P", new String[] { "" }); |
| } |
| }, null); |
| assertDeltas("Unexpected delta", |
| "P[*]: {CHILDREN | CLASSPATH CHANGED}\n" |
| + " <project root>[*]: {ADDED TO CLASSPATH}\n" |
| + " lib.jar[-]: {}\n" |
| + " ResourceDelta(/P/.classpath)[*]\n" |
| + " ResourceDelta(/P/.project)[*]"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Remove then add a java project (in a workspace runnable). |
| */ |
| public void testRemoveAddJavaProject() throws CoreException { |
| try { |
| createJavaProject("P", new String[] { "" }); |
| startDeltas(); |
| getWorkspace().run(new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| deleteProject("P"); |
| createJavaProject("P", new String[] { "" }); |
| } |
| }, null); |
| assertDeltas("Unexpected delta", |
| "P[*]: {CONTENT | CLASSPATH CHANGED}\n" |
| + " ResourceDelta(/P/.classpath)[*]\n" |
| + " ResourceDelta(/P/.project)[*]"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Change the .classpath file so as to remove a classpath entry and remove |
| * the corresponding resource. (regression test for bug 24517 type view does |
| * not notice when jar disappears) |
| */ |
| public void testRemoveCPEntryAndRoot1() throws CoreException { |
| try { |
| IJavaScriptProject project = createJavaProject("P", |
| new String[] { "src" }); |
| |
| // ensure that the project is open (there are clients of the delta |
| // only if the project is open) |
| project.open(null); |
| |
| startDeltas(); |
| JavaScriptCore.run(new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| editFile( |
| "/P/.classpath", |
| "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" |
| + "<classpath>\n" |
| + " <classpathentry kind=\"output\" path=\"bin\"/>\n" |
| + "</classpath>"); |
| deleteFolder("/P/src"); |
| } |
| }, null); |
| assertDeltas("Unexpected delta", "P[*]: {CHILDREN}\n" |
| + " src[-]: {}\n" + " ResourceDelta(/P/.classpath)[*]"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Remove a classpath entry and remove the corresponding resource. |
| * (regression test for bug 24517 type view does not notice when jar |
| * disappears) |
| */ |
| public void testRemoveCPEntryAndRoot2() throws CoreException { |
| try { |
| final IJavaScriptProject project = createJavaProject("P", |
| new String[] { "src" }); |
| |
| // ensure that the project is open (there are clients of the delta |
| // only if the project is open) |
| project.open(null); |
| |
| startDeltas(); |
| JavaScriptCore.run(new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| project.setRawIncludepath(new IIncludePathEntry[] {}, null); |
| deleteFolder("/P/src"); |
| } |
| }, null); |
| assertDeltas("Unexpected delta", |
| "P[*]: {CHILDREN | CLASSPATH CHANGED}\n" + " src[-]: {}\n" |
| + " ResourceDelta(/P/.classpath)[*]"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Remove the resource of a classpath entry and remove the classpath entry. |
| * (regression test for bug 24517 type view does not notice when jar |
| * disappears) |
| */ |
| public void testRemoveCPEntryAndRoot3() throws CoreException { |
| try { |
| final IJavaScriptProject project = createJavaProject("P", |
| new String[] { "src" }); |
| |
| // ensure that the project is open (there are clients of the delta |
| // only if the project is open) |
| project.open(null); |
| |
| startDeltas(); |
| JavaScriptCore.run(new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| deleteFolder("/P/src"); |
| project.setRawIncludepath(new IIncludePathEntry[] {}, null); |
| } |
| }, null); |
| assertDeltas("Unexpected delta", |
| "P[*]: {CHILDREN | CLASSPATH CHANGED}\n" + " src[-]: {}\n" |
| + " ResourceDelta(/P/.classpath)[*]"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Remove the java nature of an existing java project. |
| */ |
| public void testRemoveJavaNature() throws CoreException { |
| try { |
| createJavaProject("P", new String[] { "" }); |
| startDeltas(); |
| removeJavaNature("P"); |
| assertDeltas("Unexpected delta", "P[-]: {}\n" + "ResourceDelta(/P)"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| public void testRemoveJavaProject() throws CoreException { |
| try { |
| createJavaProject("P", new String[] { "" }); |
| startDeltas(); |
| deleteProject("P"); |
| assertDeltas("Unexpected delta", "P[-]: {}"); |
| } finally { |
| stopDeltas(); |
| } |
| } |
| |
| /* |
| * Remove a non-java project. |
| */ |
| public void testRemoveNonJavaProject() throws CoreException { |
| try { |
| createProject("P"); |
| startDeltas(); |
| deleteProject("P"); |
| assertDeltas("Should get a non-Java resource delta", |
| "ResourceDelta(/P)"); |
| } finally { |
| stopDeltas(); |
| } |
| } |
| |
| /* |
| * Removing a non-java project that contains a jar referenced in another |
| * project should produce a delta on this other project. (regression test |
| * for bug 19058 Closing non-java project doesn't remove root from java |
| * project) |
| */ |
| public void testRemoveNonJavaProjectUpdateDependent1() throws CoreException { |
| try { |
| createProject("SP"); |
| createFile("/SP/x.jar", ""); |
| createJavaProject("JP", new String[] { "" }, |
| new String[] { "/SP/x.jar" }); |
| startDeltas(); |
| deleteProject("SP"); |
| assertDeltas("Unexpected delta", "JP[*]: {CHILDREN}\n" |
| + " /SP/x.jar[-]: {}\n" + "ResourceDelta(/SP)"); |
| } finally { |
| stopDeltas(); |
| deleteProject("SP"); |
| deleteProject("JP"); |
| } |
| } |
| |
| /* |
| * Removing a non-java project and another project reference a non exiting |
| * folder in the deleted project should not produce a delta on this other |
| * project (and no null pointer exception) (regression test for bug 19131 |
| * NPE when removing a project containing missing classfile folder) |
| */ |
| public void testRemoveNonJavaProjectUpdateDependent2() throws CoreException { |
| try { |
| createProject("SP"); |
| createJavaProject("JP", new String[] { "" }, |
| new String[] { "/SP/missing" }); |
| startDeltas(); |
| deleteProject("SP"); |
| assertDeltas("Unexpected delta", "ResourceDelta(/SP)"); |
| } finally { |
| stopDeltas(); |
| deleteProject("SP"); |
| deleteProject("JP"); |
| } |
| } |
| |
| /* |
| * Removing a non-java project that contains a jar referenced in another |
| * project should produce a delta on this other project. Case of the removal |
| * being done right after start-up. (regression test for bug 31377 |
| * NullPointerException on binary import) |
| */ |
| public void testRemoveNonJavaProjectUpdateDependent3() throws CoreException { |
| try { |
| createProject("SP"); |
| createFile("/SP/x.jar", ""); |
| createJavaProject("JP", new String[] { "" }, |
| new String[] { "/SP/x.jar" }); |
| |
| // simulate start-up state of DeltaProcessor |
| DeltaProcessingState deltaState = JavaModelManager |
| .getJavaModelManager().deltaState; |
| deltaState.oldRoots = null; |
| deltaState.roots = null; |
| deltaState.rootsAreStale = true; |
| |
| startDeltas(); |
| JavaScriptCore.run(new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| deleteProject("SP"); |
| } |
| }, null); |
| assertDeltas("Unexpected delta", "JP[*]: {CHILDREN}\n" |
| + " /SP/x.jar[-]: {}\n" + "ResourceDelta(/SP)"); |
| } finally { |
| stopDeltas(); |
| deleteProject("SP"); |
| deleteProject("JP"); |
| } |
| } |
| |
| /* |
| * Rename a java project. (regression test for bug 7030 |
| * IllegalArgumentException renaming project) |
| */ |
| public void testRenameJavaProject() throws CoreException { |
| try { |
| createJavaProject("P", new String[] { "" }); |
| startDeltas(); |
| renameProject("P", "P1"); |
| assertDeltas("Unexpected delta", "P[-]: {MOVED_TO(P1)}\n" |
| + "P1[+]: {MOVED_FROM(P)}"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| deleteProject("P1"); |
| } |
| } |
| |
| public void testRenameMethodAndSave() throws CoreException { |
| IJavaScriptUnit workingCopy = null; |
| try { |
| createJavaProject("P", new String[] { "" }); |
| createFolder("P/x/y"); |
| createFile("P/x/y/A.js", "package x.y;\n" + "public class A {\n" |
| + " public void foo1() {\n" + " }\n" + "}"); |
| IJavaScriptUnit cu = getCompilationUnit("P/x/y/A.js"); |
| workingCopy = cu.getWorkingCopy(null); |
| workingCopy.getBuffer().setContents( |
| "package x.y;\n" + "public class A {\n" |
| + " public void foo2() {\n" + " }\n" + "}"); |
| |
| startDeltas(); |
| workingCopy.commitWorkingCopy(true, null); |
| assertDeltas( |
| "Unexpected delta", |
| "P[*]: {CHILDREN}\n" |
| + " <project root>[*]: {CHILDREN}\n" |
| + " x.y[*]: {CHILDREN}\n" |
| + " A.js[*]: {CHILDREN | FINE GRAINED | PRIMARY RESOURCE}\n" |
| + " A[*]: {CHILDREN | FINE GRAINED}\n" |
| + " foo1()[-]: {}\n" + " foo2()[+]: {}"); |
| } finally { |
| stopDeltas(); |
| if (workingCopy != null) { |
| workingCopy.discardWorkingCopy(); |
| } |
| deleteProject("P"); |
| } |
| } |
| |
| /* |
| * Rename a non-java project. (regression test for bug 30224 No JavaElement |
| * delta when renaming non-Java project) |
| */ |
| public void testRenameNonJavaProject() throws CoreException { |
| try { |
| createProject("P"); |
| startDeltas(); |
| renameProject("P", "P1"); |
| assertDeltas("Unexpected delta", "ResourceDelta(/P)\n" |
| + "ResourceDelta(/P1)"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| deleteProject("P1"); |
| } |
| } |
| |
| /* |
| * Rename an outer pkg fragment. (regression test for bug 24685 Inner |
| * package fragments gets deleted - model out of synch) |
| */ |
| public void testRenameOuterPkgFragment() throws CoreException { |
| try { |
| createJavaProject("P", new String[] { "" }); |
| createFolder("P/x/y"); |
| createFile("P/x/y/X.js", "package x.y;\n" + "public class X {\n" |
| + "}"); |
| startDeltas(); |
| IPackageFragment pkg = getPackageFragment("P", "", "x"); |
| pkg.rename("z", false, null); |
| assertDeltas("Unexpected delta", "P[*]: {CHILDREN}\n" |
| + " <project root>[*]: {CHILDREN}\n" + " z[+]: {}"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| |
| /** |
| * Ensures that saving a working copy doesn't change the underlying |
| * resource. (only commit should do so) |
| */ |
| public void testSaveWorkingCopy() throws CoreException { |
| IJavaScriptUnit copy = null; |
| try { |
| createJavaProject("P", new String[] { "" }); |
| createFile("P/X.js", "public class X {\n" + "}"); |
| IJavaScriptUnit unit = getCompilationUnit("P", "", "", "X.js"); |
| copy = unit.getWorkingCopy(null); |
| copy.getType("X").createMethod("void foo() {}", null, true, null); |
| startDeltas(); |
| copy.save(null, true); |
| assertDeltas("Unexpected delta after saving working copy", ""); |
| copy.commitWorkingCopy(true, null); |
| assertDeltas( |
| "Unexpected delta after committing working copy", |
| "P[*]: {CHILDREN}\n" |
| + " <project root>[*]: {CHILDREN}\n" |
| + " <default>[*]: {CHILDREN}\n" |
| + " X.js[*]: {CHILDREN | FINE GRAINED | PRIMARY RESOURCE}\n" |
| + " X[*]: {CHILDREN | FINE GRAINED}\n" |
| + " foo()[+]: {}"); |
| } finally { |
| stopDeltas(); |
| if (copy != null) |
| copy.discardWorkingCopy(); |
| deleteProject("P"); |
| } |
| } |
| |
| /** |
| * Ensure that a classpath change is detected even on a project which got |
| * closed |
| */ |
| public void testSetClasspathOnFreshProject() throws CoreException { |
| try { |
| createProject("LibProj"); |
| createFile("LibProj/mylib.jar", ""); |
| JavaProject p1 = (JavaProject) createJavaProject("P1", |
| new String[] { "" }); |
| createFolder("P1/src2"); |
| |
| p1.getProject().close(null); |
| p1.getProject().open(null); |
| |
| startDeltas(); |
| |
| IIncludePathEntry[] classpath = new IIncludePathEntry[] { |
| JavaScriptCore.newSourceEntry(new Path("/P1/src2")), |
| JavaScriptCore.newLibraryEntry(new Path( |
| "/LibProj/mylib.jar"), null, null) }; |
| p1.setRawIncludepath(classpath, null); |
| assertDeltas( |
| "Should notice src2 and myLib additions to the classpath", |
| "P1[*]: {CHILDREN | CLASSPATH CHANGED}\n" |
| + " <project root>[*]: {REMOVED FROM CLASSPATH}\n" |
| + " /LibProj/mylib.jar[*]: {ADDED TO CLASSPATH}\n" |
| + " src2[*]: {ADDED TO CLASSPATH}\n" |
| + " ResourceDelta(/P1/.classpath)[*]"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P1"); |
| deleteProject("LibProj"); |
| } |
| } |
| |
| /** |
| * Ensures that setting a classpath variable when there is exactly one |
| * project triggers a java element delta. |
| */ |
| public void testSetClasspathVariable1() throws CoreException { |
| try { |
| createProject("LibProj"); |
| createFile("LibProj/mylib.jar", ""); |
| createFile("LibProj/otherlib.jar", ""); |
| JavaScriptCore.setIncludepathVariables(new String[] { "LIB" }, |
| new IPath[] { new Path("/LibProj/mylib.jar") }, null); |
| createJavaProject("P", new String[] { "" }, new String[] { "LIB" }); |
| startDeltas(); |
| JavaScriptCore.setIncludepathVariables(new String[] { "LIB" }, |
| new IPath[] { new Path("/LibProj/otherlib.jar") }, null); |
| assertDeltas( |
| "Unexpected delta after setting classpath variable", |
| "P[*]: {CHILDREN}\n" |
| + " /LibProj/mylib.jar[*]: {REMOVED FROM CLASSPATH}\n" |
| + " /LibProj/otherlib.jar[*]: {ADDED TO CLASSPATH}"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| deleteProject("LibProj"); |
| } |
| } |
| |
| /** |
| * Ensures that setting a classpath variable when there are more than one |
| * project triggers a java element delta. |
| */ |
| public void testSetClasspathVariable2() throws CoreException { |
| try { |
| createProject("LibProj"); |
| createFile("LibProj/mylib.jar", ""); |
| createFile("LibProj/otherlib.jar", ""); |
| JavaScriptCore.setIncludepathVariables(new String[] { "LIB" }, |
| new IPath[] { new Path("/LibProj/mylib.jar") }, null); |
| createJavaProject("P1", new String[] { "" }, |
| new String[] { "LIB" }); |
| createJavaProject("P2", new String[] { "" }, |
| new String[] { "LIB" }); |
| startDeltas(); |
| JavaScriptCore.setIncludepathVariables(new String[] { "LIB" }, |
| new IPath[] { new Path("/LibProj/otherlib.jar") }, null); |
| assertEquals( |
| "Unexpected delta after setting classpath variable", |
| "P1[*]: {CHILDREN}\n" |
| + " /LibProj/mylib.jar[*]: {REMOVED FROM CLASSPATH}\n" |
| + " /LibProj/otherlib.jar[*]: {ADDED TO CLASSPATH}\n" |
| + "P2[*]: {CHILDREN}\n" |
| + " /LibProj/mylib.jar[*]: {REMOVED FROM CLASSPATH}\n" |
| + " /LibProj/otherlib.jar[*]: {ADDED TO CLASSPATH}", |
| getSortedByProjectDeltas()); |
| } finally { |
| stopDeltas(); |
| deleteProject("P1"); |
| deleteProject("P2"); |
| deleteProject("LibProj"); |
| } |
| } |
| |
| /** |
| * Ensures that committing a working copy fires a fine grained delta. |
| */ |
| public void testWorkingCopyCommit() throws CoreException { |
| try { |
| createJavaProject("P", new String[] { "" }); |
| createFolder("P/x/y"); |
| createFile("P/x/y/A.js", "package x.y;\n" + "public class A {\n" |
| + "}"); |
| IJavaScriptUnit cu = getCompilationUnit("P/x/y/A.js"); |
| IJavaScriptUnit copy = cu.getWorkingCopy(null); |
| copy.getBuffer().setContents( |
| "package x.y;\n" + "public class A {\n" |
| + " public void foo() {\n" + " }\n" + "}"); |
| copy.save(null, false); |
| startDeltas(); |
| copy.commitWorkingCopy(true, null); |
| assertDeltas( |
| "Unexpected delta after commit", |
| "P[*]: {CHILDREN}\n" |
| + " <project root>[*]: {CHILDREN}\n" |
| + " x.y[*]: {CHILDREN}\n" |
| + " A.js[*]: {CHILDREN | FINE GRAINED | PRIMARY RESOURCE}\n" |
| + " A[*]: {CHILDREN | FINE GRAINED}\n" |
| + " foo()[+]: {}"); |
| } finally { |
| stopDeltas(); |
| deleteProject("P"); |
| } |
| } |
| } |