| /******************************************************************************* |
| * 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 junit.framework.Test; |
| |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.resources.IWorkspaceRunnable; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.core.runtime.OperationCanceledException; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.team.core.RepositoryProvider; |
| import org.eclipse.wst.jsdt.core.IBuffer; |
| import org.eclipse.wst.jsdt.core.IField; |
| import org.eclipse.wst.jsdt.core.IFunction; |
| import org.eclipse.wst.jsdt.core.IJavaScriptElement; |
| import org.eclipse.wst.jsdt.core.IJavaScriptModelStatusConstants; |
| import org.eclipse.wst.jsdt.core.IJavaScriptUnit; |
| import org.eclipse.wst.jsdt.core.IOpenable; |
| import org.eclipse.wst.jsdt.core.IPackageFragment; |
| import org.eclipse.wst.jsdt.core.JavaScriptCore; |
| import org.eclipse.wst.jsdt.core.JavaScriptModelException; |
| import org.eclipse.wst.jsdt.core.WorkingCopyOwner; |
| import org.eclipse.wst.jsdt.internal.core.util.Util; |
| |
| |
| |
| public class WorkingCopyTests extends ModifyingResourceTests { |
| IJavaScriptUnit cu = null; |
| IJavaScriptUnit copy = null; |
| |
| public class TestWorkingCopyOwner extends WorkingCopyOwner { |
| public IBuffer createBuffer(IJavaScriptUnit workingCopy) { |
| return new TestBuffer(workingCopy); |
| } |
| } |
| public WorkingCopyTests(String name) { |
| super(name); |
| } |
| |
| public static Test suite() { |
| return buildModelTestSuite(WorkingCopyTests.class); |
| } |
| protected void setUp() throws Exception { |
| super.setUp(); |
| |
| try { |
| this.createJavaProject( |
| "P", |
| new String[] {"src"}, |
| new String[] {this.getSystemJsPathString(), "lib"}); |
| // this.createFolder("P/src"); |
| this.createFile("P/src/A.js", |
| " var FIELD;\n" + |
| " var field1;\n" + |
| " var field2;\n" + |
| " function foo() {\n" + |
| " }\n" + |
| ""); |
| this.cu = this.getCompilationUnit("P/src/A.js"); |
| this.copy = cu.getWorkingCopy(null); |
| } catch (CoreException e) { |
| e.printStackTrace(); |
| throw new RuntimeException(e.getMessage()); |
| } |
| } |
| protected void tearDown() throws Exception { |
| if (this.copy != null) this.copy.discardWorkingCopy(); |
| this.deleteProject("P"); |
| super.tearDown(); |
| } |
| /* |
| * Ensures that cancelling a make consistent operation doesn't leave the working copy closed |
| * (regression test for bug 61719 Incorrect fine grain delta after method copy-rename) |
| */ |
| public void testCancelMakeConsistent() throws JavaScriptModelException { |
| String newContents = |
| " function bar() {\n" + |
| " }\n" + |
| ""; |
| this.copy.getBuffer().setContents(newContents); |
| NullProgressMonitor monitor = new NullProgressMonitor(); |
| monitor.setCanceled(true); |
| try { |
| this.copy.makeConsistent(monitor); |
| } catch (OperationCanceledException e) { |
| // got exception |
| } |
| assertTrue("Working copy should be opened", this.copy.isOpen()); |
| } |
| |
| /** |
| */ |
| public void testChangeContent() throws CoreException { |
| String newContents = |
| " function bar() {\n" + |
| "}"; |
| this.copy.getBuffer().setContents(newContents); |
| this.copy.reconcile(IJavaScriptUnit.NO_AST, false, null, null); |
| assertSourceEquals( |
| "Unexpected working copy contents", |
| newContents, |
| this.copy.getBuffer().getContents()); |
| |
| this.copy.commitWorkingCopy(true, null); |
| assertSourceEquals( |
| "Unexpected original cu contents", |
| newContents, |
| this.cu.getBuffer().getContents()); |
| } |
| |
| /* |
| * Ensures that one cannot commit the contents of a working copy on a read only cu. |
| */ |
| public void testChangeContentOfReadOnlyCU1() throws CoreException { |
| if (!Util.isReadOnlySupported()) { |
| // Do not test if file system does not support read-only attribute |
| return; |
| } |
| IResource resource = this.cu.getUnderlyingResource(); |
| boolean readOnlyFlag = Util.isReadOnly(resource); |
| boolean didComplain = false; |
| try { |
| Util.setReadOnly(resource, true); |
| this.copy.getBuffer().setContents("invalid"); |
| this.copy.commitWorkingCopy(true, null); |
| } catch(JavaScriptModelException e){ |
| didComplain = true; |
| } finally { |
| Util.setReadOnly(resource, readOnlyFlag); |
| } |
| assertTrue("Should have complained about modifying a read-only unit:", didComplain); |
| assertTrue("ReadOnly buffer got modified:", !this.cu.getBuffer().getContents().equals("invalid")); |
| } |
| |
| /* |
| * Ensures that one can commit the contents of a working copy on a read only cu if a pessimistic repository |
| * provider allows it. |
| */ |
| public void testChangeContentOfReadOnlyCU2() throws CoreException { |
| if (!Util.isReadOnlySupported()) { |
| // Do not test if file system does not support read-only attribute |
| return; |
| } |
| String newContents = |
| " function bar() {\n" + |
| "}"; |
| IResource resource = this.cu.getUnderlyingResource(); |
| IProject project = resource.getProject(); |
| boolean readOnlyFlag = Util.isReadOnly(resource); |
| try { |
| RepositoryProvider.map(project, TestPessimisticProvider.NATURE_ID); |
| TestPessimisticProvider.markWritableOnSave = true; |
| Util.setReadOnly(resource, true); |
| |
| this.copy.getBuffer().setContents(newContents); |
| this.copy.commitWorkingCopy(true, null); |
| assertSourceEquals( |
| "Unexpected original cu contents", |
| newContents, |
| this.cu.getBuffer().getContents()); |
| } finally { |
| TestPessimisticProvider.markWritableOnSave = false; |
| RepositoryProvider.unmap(project); |
| Util.setReadOnly(resource, readOnlyFlag); |
| } |
| } |
| |
| /** |
| * Ensures that the source contents of a working copy are |
| * not altered by changes to the source of the original compilation |
| * unit. |
| */ |
| public void testContents() throws CoreException { |
| String originalSource = this.cu.getSource(); |
| IField type = this.cu.getField("field1"); |
| assertDeletion(type); |
| assertSourceEquals("source code of copy should still be original", originalSource, this.copy.getSource()); |
| } |
| |
| ///** |
| // * Test creating a working copy on a class file with a customized buffer. |
| // */ |
| //public void testOnClassFile() throws JavaScriptModelException, IOException { |
| // // ensure the external JCL is copied |
| // setupExternalJCL("jclMin"); |
| // |
| // this.attachSource(this.getPackageFragmentRoot("P", this.getExternalJCLPathString()), this.getExternalJCLSourcePath().toOSString(), "src"); |
| // IClassFile classFile = this.getClassFile("P", this.getExternalJCLPathString(), "java.lang", "Object.class"); |
| // WorkingCopyOwner owner = new TestWorkingCopyOwner(); |
| // IJavaScriptUnit customizedCopy = classFile.getWorkingCopy(owner, null); |
| // try { |
| // IBuffer buffer = customizedCopy.getBuffer(); |
| // assertTrue("Unexpected buffer", buffer instanceof TestBuffer); |
| // assertTrue("Buffer should be initialized with source", buffer.getCharacters().length > 0); |
| // } finally { |
| // customizedCopy.discardWorkingCopy(); |
| // } |
| //} |
| /** |
| * Create the compilation unit place holder for the working copy tests. |
| */ |
| public void testCreation() { |
| assertTrue("Failed to create X.js compilation unit", this.cu != null && this.cu.exists()); |
| assertTrue("Failed to create working copy on X.js", this.copy != null && this.copy.exists()); |
| } |
| |
| /** |
| * Test creating a working copy with a customized buffer. |
| */ |
| public void testCustomizedBuffer() throws JavaScriptModelException { |
| WorkingCopyOwner owner = new TestWorkingCopyOwner(); |
| IJavaScriptUnit customizedCopy = this.cu.getWorkingCopy(owner, null); |
| try { |
| assertTrue("Unexpected buffer", customizedCopy.getBuffer() instanceof TestBuffer); |
| } finally { |
| customizedCopy.discardWorkingCopy(); |
| } |
| } |
| /** |
| * Test closing then reopening a working copy with a customized buffer. |
| */ |
| public void testCustomizedBuffer2() throws JavaScriptModelException { |
| WorkingCopyOwner owner = new TestWorkingCopyOwner(); |
| IJavaScriptUnit customizedCopy = this.cu.getWorkingCopy(owner, null); |
| try { |
| customizedCopy.close(); |
| customizedCopy.open(null); |
| assertTrue("Unexpected buffer", customizedCopy.getBuffer() instanceof TestBuffer); |
| } finally { |
| customizedCopy.discardWorkingCopy(); |
| } |
| } |
| /* |
| * Test that deleting 2 fields in a JavaScriptCore.run() operation reports the correct delta. |
| * (regression test for bug 32225 incorrect delta after deleting 2 fields) |
| */ |
| public void testDelete2Fields() throws CoreException { |
| try { |
| startDeltas(); |
| JavaScriptCore.run( |
| new IWorkspaceRunnable() { |
| public void run(IProgressMonitor monitor) throws CoreException { |
| IField field1 = copy.getField("field1"); |
| IField field2 = copy.getField("field2"); |
| field1.delete(false, monitor); |
| field2.delete(false, monitor); |
| } |
| }, |
| null); |
| assertDeltas( |
| "Unexpected delta", |
| "field1[-]: {}\n" + |
| "field2[-]: {}" |
| ); |
| } finally { |
| stopDeltas(); |
| } |
| } |
| /** |
| * Tests the general functionality of a working copy:<ul> |
| * <li>ensures that the copy and original compilation unit are not equal</li> |
| * <li>ensures the correct retrieval of the original element</li> |
| * <li>closing the package of the compilation unit does not close the copy</li> |
| * <li>ensures that working copies are unique |
| * <li>ensures committing changes from working copies |
| */ |
| public void testGeneral() throws JavaScriptModelException, CoreException { |
| |
| assertTrue("copy and actual should not be equal", !this.copy.equals(this.cu)); |
| |
| IField copyfield= this.copy.getField("field1"); |
| |
| assertEquals("primary should be the samel", this.cu, this.cu.getPrimary()); |
| |
| assertEquals("getting working copy from a copy should yield original copy", this.copy, this.copy.getWorkingCopy(null)); |
| |
| boolean ex= false; |
| assertDeletion(copyfield); |
| |
| // closing the package should not close the copy |
| ((IOpenable)this.cu.getParent()).close(); |
| assertTrue("copy should still be open", this.copy.isOpen()); |
| |
| // verify original still present |
| assertTrue("actual type should still be present", this.cu.getField("field1").exists()); |
| |
| // getAnother working copy |
| IJavaScriptUnit copy2= this.cu.getWorkingCopy(null); |
| try { |
| assertTrue("working copies should be unique ", !(this.copy.equals(copy2))); |
| |
| // delete a method from the 2nd working copy. |
| IFunction method= copy2.getFunction("foo", null); |
| |
| assertDeletion(method); |
| IFunction originalMethod= this.cu.getFunction("foo", null); |
| assertTrue("method should still be present in original", originalMethod.exists()); |
| |
| // commit the changes from the 2nd copy. |
| copy2.commitWorkingCopy(false, null); |
| |
| assertTrue("copy always has unsaved changes", copy2.hasUnsavedChanges()); |
| |
| // original method should now be gone |
| assertTrue("method should no longer be present in original after commit", !originalMethod.exists()); |
| |
| // commit the changes from the 1st copy - should fail |
| try { |
| this.copy.commitWorkingCopy(false, null); |
| assertTrue("commit should have failed", ex); |
| } catch (JavaScriptModelException jme) { |
| } |
| |
| |
| // now force the update |
| try { |
| this.copy.commitWorkingCopy(true, null); |
| } catch (JavaScriptModelException jme) { |
| assertTrue("commit should work", false); |
| } |
| |
| // now the type should be gone. |
| assertTrue("original type should no longer be present", !this.cu.getField("field1").exists()); |
| |
| |
| this.copy.close(); |
| ex= false; |
| try { |
| this.copy.open(null); |
| } catch (JavaScriptModelException e) { |
| ex= true; |
| } |
| assertTrue("should be able to open working copy a 2nd time", !ex); |
| |
| // now discard the working copy |
| this.copy.discardWorkingCopy(); |
| ex= false; |
| try { |
| this.copy.open(null); |
| } catch (JavaScriptModelException e) { |
| ex= true; |
| } |
| assertTrue("should not be able to open working copy again", ex); |
| } finally { |
| copy2.discardWorkingCopy(); |
| } |
| } |
| ///** |
| // * Ensures that the primary element of a binary element is itself. |
| // */ |
| //public void testGetPrimaryBinaryElement() throws CoreException { |
| // /* Evaluate the following in a scrapbook: |
| // org.eclipse.wst.jsdt.core.tests.model.ModifyingResourceTests.generateClassFile( |
| // "A", |
| // "public class A {\n" + |
| // "}") |
| // */ |
| // byte[] bytes = new byte[] { |
| // -54, -2, -70, -66, 0, 3, 0, 45, 0, 10, 1, 0, 1, 65, 7, 0, 1, 1, 0, 16, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 79, 98, 106, 101, 99, 116, 7, 0, 3, 1, 0, 6, 60, 105, 110, 105, 116, 62, 1, 0, 3, 40, 41, 86, 1, 0, 4, 67, 111, 100, 101, 12, 0, 5, 0, 6, 10, 0, 4, 0, 8, 0, 33, 0, 2, 0, 4, 0, 0, 0, |
| // 0, 0, 1, 0, 1, 0, 5, 0, 6, 0, 1, 0, 7, 0, 0, 0, 17, 0, 1, 0, 1, 0, 0, 0, 5, 42, -73, 0, 9, -79, 0, 0, 0, 0, 0, 0, |
| // }; |
| // this.createFile("P/lib/A.class", bytes); |
| // IClassFile cf = this.getClassFile("P/lib/A.class"); |
| // IJavaScriptElement primary = cf.getPrimaryElement(); |
| // assertEquals("Primary element should be the same", cf, primary); |
| //} |
| /** |
| * Ensures that the primary cu can be retrieved. |
| */ |
| public void testGetPrimaryCU() { |
| IJavaScriptElement primary= this.copy.getPrimaryElement(); |
| assertTrue("Element is not a cu", primary instanceof IJavaScriptUnit && !((IJavaScriptUnit)primary).isWorkingCopy()); |
| assertTrue("Element should exist", primary.exists()); |
| } |
| /** |
| * Ensures that the primary field can be retrieved. |
| */ |
| public void testGetPrimaryField() { |
| IJavaScriptElement primary = this.copy.getField("FIELD").getPrimaryElement(); |
| assertTrue("Element is not a field", primary instanceof IField && !((IJavaScriptUnit)primary.getParent()).isWorkingCopy()); |
| assertTrue("Element should exist", primary.exists()); |
| } |
| ///** |
| // * Ensures that the primary import declaration can be retrieved. |
| // */ |
| //public void testGetPrimaryImportDeclaration() { |
| // IImportDeclaration imprt = copy.getImport("java.io.File"); |
| // IJavaScriptElement primary = imprt.getPrimaryElement(); |
| // assertTrue("Element should exist", primary.exists()); |
| //} |
| ///** |
| // * Ensures that the primary import container can be retrieved. |
| // */ |
| //public void testGetPrimaryImportContainer() { |
| // IImportContainer container = this.copy.getImportContainer(); |
| // IJavaScriptElement primary = container.getPrimaryElement(); |
| // assertTrue("Element should not be null", primary != null); |
| // assertTrue("Element should exist", primary.exists()); |
| //} |
| /////** |
| //// * Ensures that the primary initializer can be retrieved. |
| //// */ |
| ////public void testGetPrimaryInitializer() { |
| //// IType type= copy.getType("A"); |
| //// IJavaScriptElement primary= type.getInitializer(1).getPrimaryElement(); |
| //// assertTrue("Element should exist", primary.exists()); |
| ////} |
| ///** |
| // */ |
| //public void testGetPrimaryInnerField() { |
| // IType innerType = this.copy.getType("A").getType("Inner"); |
| // IJavaScriptElement primary = innerType.getField("innerField").getPrimaryElement(); |
| // assertTrue("Element is not a field", primary instanceof IField); |
| // assertTrue("Element should exist", primary.exists()); |
| //} |
| ///** |
| // */ |
| //public void testGetPrimaryInnerMethod() throws JavaScriptModelException { |
| // IType innerType = this.copy.getType("A").getType("Inner"); |
| // IJavaScriptElement primary = innerType.getMethods()[0].getPrimaryElement(); |
| // assertTrue("Element is not a method", primary instanceof IFunction); |
| // assertTrue("Element should exist", primary.exists()); |
| //} |
| ///** |
| // */ |
| //public void testGetPrimaryInnerType() { |
| // IType innerInnerType = this.copy.getType("A").getType("Inner").getType("InnerInner"); |
| // IJavaScriptElement primary = innerInnerType.getPrimaryElement(); |
| // assertTrue("Element is not a method", primary instanceof IType); |
| // assertTrue("Element should exist", primary.exists()); |
| // |
| // Vector hierarchy = new Vector(5); |
| // IJavaScriptElement parent= primary.getParent(); |
| // while (parent.getElementType() > IJavaScriptElement.JAVASCRIPT_UNIT) { |
| // hierarchy.addElement(parent); |
| // parent = parent.getParent(); |
| // } |
| // hierarchy.addElement(parent); |
| // assertTrue("Compilation Unit should not be a working copy", !((IJavaScriptUnit)hierarchy.lastElement()).isWorkingCopy()); |
| //} |
| /** |
| * Ensures that the primary method can be retrieved. |
| */ |
| public void testGetPrimaryMethod() throws JavaScriptModelException { |
| IJavaScriptElement primary= this.copy.getFunctions()[0].getPrimaryElement(); |
| assertTrue("Element is not a method", primary instanceof IFunction); |
| assertTrue("Element should exist", primary.exists()); |
| } |
| /** |
| * Ensures that renaming a method of a working copy does |
| * not alter the source of the primary compilation |
| * unit. |
| */ |
| public void testRenameMethod() throws JavaScriptModelException { |
| IFunction method = this.copy.getFunctions()[0]; |
| IJavaScriptElement primary= method.getPrimaryElement(); |
| method.rename("bar", false, null); |
| assertEquals("Invalid name of working copy method", "bar", this.copy.getFunctions()[0].getElementName()); |
| assertEquals("Invalid name of primary method", "foo", primary.getElementName()); |
| } |
| ///** |
| // * Ensures that the primary package declaration can be retrieved. |
| // */ |
| //public void testGetPrimaryPackageDeclaration() { |
| // IPackageDeclaration pkg = this.copy.getPackageDeclaration("x.y"); |
| // IJavaScriptElement primary = pkg.getPrimaryElement(); |
| // assertTrue("Element should exist", primary.exists()); |
| //} |
| ///** |
| // * Ensures that the primary type can be retrieved. |
| // */ |
| //public void testGetPrimaryType() { |
| // IType type = this.copy.getType("A"); |
| // IJavaScriptElement primary= type.getPrimaryElement(); |
| // assertTrue("Element should exist", primary.exists()); |
| //} |
| /** |
| * Ensures that a type can be moved to another working copy. |
| * (regression test for bug 7881 IType.move() clobbers editing buffer of destination element) |
| */ |
| public void testMoveTypeToAnotherWorkingCopy() throws CoreException { |
| this.createFile( |
| "P/src/B.js", |
| "function B() {\n" + |
| "}"); |
| IJavaScriptUnit cu2 = this.getCompilationUnit("P/src/B.js"); |
| IJavaScriptUnit copy2 = cu2.getWorkingCopy(null); |
| try { |
| IField fld1 = this.copy.getField("field1"); |
| // IType classB = copy2.getType("B"); |
| fld1.move(copy2, null, null, false, null); |
| assertTrue("A should not exist", !fld1.exists()); |
| assertTrue("B.A should exist", copy2.getField("field1").exists()); |
| assertTrue("Buffer for A should not be null", this.copy.getBuffer() != null); |
| assertSourceEquals("Invalid content for A", |
| " var FIELD;\n" + |
| " var field2;\n" + |
| " function foo() {\n" + |
| " }\n" , |
| this.copy.getBuffer().getContents()); |
| assertTrue("Buffer for B should not be null", copy2.getBuffer() != null); |
| assertSourceEquals("Invalid content for B", |
| "var field1;\n" + |
| "\n" + |
| "function B() {\n" + |
| "}", |
| copy2.getBuffer().getContents()); |
| } finally { |
| copy2.discardWorkingCopy(); |
| } |
| } |
| /** |
| * Test creating a shared working copy. |
| */ |
| public void testShared1() throws JavaScriptModelException { |
| WorkingCopyOwner owner = new WorkingCopyOwner() {}; |
| IJavaScriptUnit shared = this.cu.getWorkingCopy(owner, null); |
| try { |
| assertTrue("Should find shared working copy", this.cu.findWorkingCopy(owner) == shared); |
| } finally { |
| shared.discardWorkingCopy(); |
| } |
| assertTrue("Should not find cu with same owner", this.cu.findWorkingCopy(owner) == null); |
| } |
| /** |
| * Test several call to creating shared working copy. |
| */ |
| public void testShared2() throws JavaScriptModelException { |
| WorkingCopyOwner owner = new WorkingCopyOwner() {}; |
| IJavaScriptUnit shared = this.cu.getWorkingCopy(owner, null); |
| try { |
| IJavaScriptUnit shared2 = this.cu.getWorkingCopy(owner, null); |
| assertTrue("Second working copy should be identical to first one", shared2 == shared); |
| } finally { |
| shared.discardWorkingCopy(); |
| try { |
| assertTrue("Should find shared working copy", this.cu.findWorkingCopy(owner) == shared); |
| } finally { |
| shared.discardWorkingCopy(); |
| } |
| } |
| assertTrue("Should not find cu with same owner", this.cu.findWorkingCopy(owner) == null); |
| } |
| /** |
| * Tests that multiple commits are possible with the same working copy. |
| */ |
| public void testMultipleCommit() { |
| |
| // Add a method to the working copy |
| // IType gp = this.copy.getType("A"); |
| try { |
| this.copy.createMethod("function anotherMethod() {}\n",null, false, null); |
| } catch (JavaScriptModelException jme) { |
| assertTrue("creation failed", false); |
| } |
| |
| // commit the changes from the copy. |
| try { |
| this.copy.commitWorkingCopy(false, null); |
| } catch (JavaScriptModelException t) { |
| assertTrue("commit failed", false); |
| } |
| |
| // new method added |
| assertTrue("method should exist after commit", |
| this.cu.getFunction("anotherMethod", new String[]{}).exists()); |
| |
| //add another method |
| try { |
| this.copy.createMethod("function anotherAnotherMethod() {}\n", null, false, null); |
| } catch (JavaScriptModelException x) { |
| assertTrue("Creation failed 2", false); |
| } |
| |
| //commit the new method |
| try { |
| this.copy.commitWorkingCopy(false, null); |
| } catch (JavaScriptModelException t) { |
| assertTrue("commit2 failed", false); |
| } |
| |
| // new method added |
| assertTrue("second method added should exist after commit", |
| this.cu.getFunction("anotherAnotherMethod", new String[]{}).exists()); |
| } |
| /** |
| * Creates a working copy on a non-existing compilation unit. |
| * (regression test for bug 8921 DCR - Need a way to create a working copy ignoring existing files) |
| */ |
| public void testNonExistingCU() throws JavaScriptModelException { |
| IJavaScriptUnit nonExistingCU = this.getCompilationUnit("P/src/NonExisting.js"); |
| IJavaScriptUnit workingCopy = null; |
| try { |
| // getBuffer() |
| workingCopy = nonExistingCU.getWorkingCopy(null); |
| assertSourceEquals("Buffer should be empty", "", ((IOpenable)workingCopy).getBuffer().getContents()); |
| |
| // exists() |
| assertTrue("Working copy should exists", ((IJavaScriptElement)workingCopy).exists()); |
| |
| // getCorrespondingResource() |
| assertEquals("Corresponding resource should be null", null, ((IJavaScriptElement)workingCopy).getCorrespondingResource()); |
| |
| // getPrimaryElement() |
| assertEquals("Unexpected orginal element", nonExistingCU, workingCopy.getPrimaryElement()); |
| |
| // getPath() |
| assertEquals("Unexpected path", new Path("/P/src/NonExisting.js"), ((IJavaScriptElement)workingCopy).getPath()); |
| |
| // getResource() |
| assertEquals("Unexpected resource", nonExistingCU.getResource(), ((IJavaScriptElement)workingCopy).getResource()); |
| |
| // isConsistent() |
| assertTrue("Working copy should be consistent", ((IOpenable)workingCopy).isConsistent()); |
| |
| // restore() |
| boolean exception = false; |
| try { |
| workingCopy.restore(); |
| } catch (JavaScriptModelException e) { |
| exception = true; |
| } |
| assertTrue("Should not be able to restore from primary element", exception); |
| |
| // makeConsistent() |
| ((IOpenable)workingCopy).getBuffer().setContents( |
| "function X() {\n" + |
| "}"); |
| assertTrue("Working copy should not be consistent", !((IOpenable)workingCopy).isConsistent()); |
| ((IOpenable)workingCopy).makeConsistent(null); |
| assertTrue("Working copy should be consistent", ((IOpenable)workingCopy).isConsistent()); |
| |
| // save() |
| ((IOpenable)workingCopy).getBuffer().setContents( |
| "function Y() {\n" + |
| "}"); |
| ((IOpenable)workingCopy).save(null, false); |
| assertTrue("Working copy should be consistent after save", ((IOpenable)workingCopy).isConsistent()); |
| assertTrue("Primary cu should not exist", !nonExistingCU.exists()); |
| |
| // commitWorkingCopy() |
| workingCopy.commitWorkingCopy(false, null); |
| assertTrue("Primary cu should exist", nonExistingCU.exists()); |
| |
| // hasResourceChanged() |
| assertTrue("Working copy's resource should now not mark as changed", !workingCopy.hasResourceChanged()); |
| |
| } finally { |
| if (workingCopy != null) { |
| workingCopy.discardWorkingCopy(); |
| } |
| if (nonExistingCU.exists()) { |
| nonExistingCU.delete(true, null); |
| } |
| } |
| } |
| /** |
| * Tests the general functionality of a operations working with working copies:<ul> |
| * <li>ensures that the copy cannot be renamed</li> |
| * <li>ensures that the copy cannot be moved to the same location as the primary cu</li> |
| * <li>ensures that the copy can be copied to a different location as the primary cu</li> |
| */ |
| public void testOperations() throws JavaScriptModelException { |
| // rename working copy |
| boolean ex= false; |
| try { |
| this.copy.rename("someName.js", false, null); |
| } catch (JavaScriptModelException jme) { |
| assertTrue("Incorrect status code for attempting to rename working copy", jme.getStatus().getCode() == IJavaScriptModelStatusConstants.INVALID_ELEMENT_TYPES); |
| ex= true; |
| } |
| assertTrue("renaming a working copy should fail", ex); |
| |
| // move to same location as primary cu |
| ex= false; |
| try { |
| this.copy.move(this.cu.getParent(), null, "someName.js", false, null); |
| } catch (JavaScriptModelException jme) { |
| assertTrue("Incorrect status code for attempting to move working copy", jme.getStatus().getCode() == IJavaScriptModelStatusConstants.INVALID_ELEMENT_TYPES); |
| ex= true; |
| } |
| assertTrue("moving a working copy should fail", ex); |
| |
| // copy working copy to default package |
| IPackageFragment pkg= getPackageFragment("P", "src", ""); |
| this.copy.copy(pkg, null, "someName.js", false, null); |
| assertCreation(this.copy); |
| } |
| } |