tests/org.eclipse.wst.jsdt.core.tests.model/src/org/eclipse/wst/jsdt/core/tests/model/WorkingCopyTests.java

/*******************************************************************************
 * 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);	
}
}