Attachment #207292 for bug #362711

Lines 2452-2458 Link Here

(-)a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/CopyMoveElementsTests.java (-2 / +2 lines)
2452	try {	2452	try {
2453	TestProgressMonitor monitor = TestProgressMonitor.getInstance();	2453	TestProgressMonitor monitor = TestProgressMonitor.getInstance();
2454	monitor.setCancelledCounter(1);	2454	monitor.setCancelledCounter(1);
2455	movePositive(typeSource.getMethods(), new IJavaElement[] {typeDest}, null, null, false, monitor);	2455	movePositive(typeSource.getMethods(), new IJavaElement[] {typeDest}, null, null, false, true, monitor);
2456	} catch (OperationCanceledException e) {	2456	} catch (OperationCanceledException e) {
2457	isCanceled = true;	2457	isCanceled = true;
2458	}	2458	}
Lines 2488-2494 Link Here
2488	try {	2488	try {
2489	TestProgressMonitor monitor = TestProgressMonitor.getInstance();	2489	TestProgressMonitor monitor = TestProgressMonitor.getInstance();
2490	monitor.setCancelledCounter(1);	2490	monitor.setCancelledCounter(1);
2491	movePositive(typeSource.getMethods(), new IJavaElement[] {typeDest}, null, null, false, monitor);	2491	movePositive(typeSource.getMethods(), new IJavaElement[] {typeDest}, null, null, false, true, monitor);
2492	} catch (OperationCanceledException e) {	2492	} catch (OperationCanceledException e) {
2493	isCanceled = true;	2493	isCanceled = true;
2494	}	2494	}




		}
		IJavaElementDelta destDelta = this.deltaListener.getDeltaFor(container, true);
		assertTrue("Destination container not changed", destDelta != null && destDelta.getKind() == IJavaElementDelta.CHANGED);
		IJavaElementDelta[] deltas = null;
		if (force) {
			deltas = destDelta.getChangedChildren();
		}
		else {
			deltas = destDelta.getAddedChildren();
		}
		// FIXME: not strong enough
		boolean found = false;
		for (int i = 0; i < deltas.length; i++) {

 * existing CU.
 */
public void testMoveCU03() throws CoreException {
	try {
		this.createFolder("/P/src/p1");
		this.createFile(
			"/P/src/p1/X.java",
			"package p1;\n" +
			"public class X {\n" +
			"}"
		);
		ICompilationUnit cuSource = getCompilationUnit("/P/src/p1/X.java");

		this.createFolder("/P/src/p2");
		this.createFile(
			"/P/src/p2/X.java",
			"package p2;\n" +
			"public class X {\n" +
			"}"
		);
		IPackageFragment pkgDest = getPackage("/P/src/p2");
		startDeltas();
		movePositive(new IJavaElement[] {cuSource}, new IJavaElement[] {pkgDest}, null, null, true, false, null);
			assertDeltas(
					"Incorrect delta",
					"P[*]: {CHILDREN}\n"
							+ "	src[*]: {CHILDREN}\n"
							+ "		p1[*]: {CHILDREN}\n"
							+ "			X.java[-]: {MOVED_TO(X.java [in p2 [in src [in P]]])}\n"
							+ "		p2[*]: {CHILDREN}\n"
							+ "			X.java[*]: {CONTENT | PRIMARY RESOURCE}");
	}
	finally {
		stopDeltas();
	}
}
/**
 * Ensures that a CU can be moved to a different package,

 * be renamed, overwriting an existing resource.
 */
public void testMoveCU05() throws CoreException {
	try {
		this.createFolder("/P/src/p1");
		this.createFile(
			"/P/src/p1/X.java",
			"package p1;\n" +
			"public class X {\n" +
			"}"
		);
		ICompilationUnit cuSource = getCompilationUnit("/P/src/p1/X.java");

		this.createFolder("/P/src/p2");
		this.createFile(
			"/P/src/p2/Y.java",
			"package p2;\n" +
			"public class Y {\n" +
			"}"
		);
		IPackageFragment pkgDest = getPackage("/P/src/p2");
		startDeltas();
		movePositive(new IJavaElement[] {cuSource}, new IJavaElement[] {pkgDest}, null, new String[]{"Y.java"}, true, false, null);
		assertDeltas(
					"Incorrect delta",
					"P[*]: {CHILDREN}\n"
							+ "	src[*]: {CHILDREN}\n"
							+ "		p1[*]: {CHILDREN}\n"
							+ "			X.java[-]: {MOVED_TO(Y.java [in p2 [in src [in P]]])}\n"
							+ "		p2[*]: {CHILDREN}\n"
							+ "			Y.java[*]: {CHILDREN | FINE GRAINED | PRIMARY RESOURCE}\n"
							+ "				Y[+]: {MOVED_FROM(X [in X.java [in p1 [in src [in P]]]])}");
	}
	finally {
		stopDeltas();
	}
}
/**
 * Ensures that a CU cannot be moved to a different package, replacing an

Lines 253-264 Link Here

(-)a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/CopyMoveTests.java (-17 / +22 lines)
253	public void movePositive(IJavaElement[] elements, IJavaElement[] destinations, IJavaElement[] siblings, String[] names, boolean force) throws JavaModelException {	253	public void movePositive(IJavaElement[] elements, IJavaElement[] destinations, IJavaElement[] siblings, String[] names, boolean force) throws JavaModelException {
254	movePositive(elements, destinations, siblings, names, force, null);	254	movePositive(elements, destinations, siblings, names, force, null);
255	}	255	}
		256	public void movePositive(IJavaElement[] elements, IJavaElement[] destinations, IJavaElement[] siblings, String[] names, boolean force, IProgressMonitor monitor) throws JavaModelException {
		257	movePositive(elements, destinations, siblings, names, force, true, null);
		258	}
256	/**	259	/**
257	* Moves the elements to the containers with optional renaming	260	* Moves the elements to the containers with optional renaming
258	* and forcing. The operation should succeed, so any exceptions	261	* and forcing. The operation should succeed, so any exceptions
259	* encountered are thrown.	262	* encountered are thrown.
260	*/	263	*/
261	public void movePositive(IJavaElement[] elements, IJavaElement[] destinations, IJavaElement[] siblings, String[] names, boolean force, IProgressMonitor monitor) throws JavaModelException {	264	public void movePositive(IJavaElement[] elements, IJavaElement[] destinations, IJavaElement[] siblings, String[] names, boolean force, boolean checkDelta, IProgressMonitor monitor) throws JavaModelException {
262	// if forcing, ensure that a name collision exists	265	// if forcing, ensure that a name collision exists
263	int i;	266	int i;
264	if (force) {	267	if (force) {
Lines 275-281 Link Here
275	}	278	}
276		279
277	try {	280	try {
278	startDeltas();	281	if(checkDelta) startDeltas();
279		282
280	// move	283	// move
281	getJavaModel().move(elements, destinations, siblings, names, force, monitor);	284	getJavaModel().move(elements, destinations, siblings, names, force, monitor);
Lines 341-364 Link Here
341	}	344	}
342	}	345	}
343	}	346	}
344	IJavaElementDelta destDelta = null;	347	if(checkDelta) {
345	if (isMainType(element, destinations[i]) && names != null && names[i] != null) { //moved/renamed main type to same cu	348	IJavaElementDelta destDelta = null;
346	destDelta = this.deltaListener.getDeltaFor(moved.getParent());	349	if (isMainType(element, destinations[i]) && names != null && names[i] != null) { //moved/renamed main type to same cu
347	assertTrue("Renamed compilation unit as result of main type not added", destDelta != null && destDelta.getKind() == IJavaElementDelta.ADDED);	350	destDelta = this.deltaListener.getDeltaFor(moved.getParent());
348	assertTrue("flag should be F_MOVED_FROM", (destDelta.getFlags() & IJavaElementDelta.F_MOVED_FROM) > 0);	351	assertTrue("Renamed compilation unit as result of main type not added", destDelta != null && destDelta.getKind() == IJavaElementDelta.ADDED);
349	assertTrue("moved from handle should be original", destDelta.getMovedFromElement().equals(element.getParent()));	352	assertTrue("flag should be F_MOVED_FROM", (destDelta.getFlags() & IJavaElementDelta.F_MOVED_FROM) > 0);
350	} else {	353	assertTrue("moved from handle should be original", destDelta.getMovedFromElement().equals(element.getParent()));
351	destDelta = this.deltaListener.getDeltaFor(destinations[i], true);	354	} else {
352	assertTrue("Destination container not changed", destDelta != null && destDelta.getKind() == IJavaElementDelta.CHANGED);	355	destDelta = this.deltaListener.getDeltaFor(destinations[i], true);
353	IJavaElementDelta[] deltas = destDelta.getAddedChildren();	356	assertTrue("Destination container not changed", destDelta != null && destDelta.getKind() == IJavaElementDelta.CHANGED);
354	assertTrue("Added children not correct for element copy", deltas[i].getElement().equals(moved));	357	IJavaElementDelta[] deltas = destDelta.getAddedChildren();
355	assertTrue("should be K_ADDED", deltas[i].getKind() == IJavaElementDelta.ADDED);	358	assertTrue("Added children not correct for element copy", deltas[i].getElement().equals(moved));
356	IJavaElementDelta sourceDelta= this.deltaListener.getDeltaFor(element, false);	359	assertTrue("should be K_ADDED", deltas[i].getKind() == IJavaElementDelta.ADDED);
357	assertTrue("should be K_REMOVED", sourceDelta.getKind() == IJavaElementDelta.REMOVED);	360	IJavaElementDelta sourceDelta= this.deltaListener.getDeltaFor(element, false);
		361	assertTrue("should be K_REMOVED", sourceDelta.getKind() == IJavaElementDelta.REMOVED);
		362	}
358	}	363	}
359	}	364	}
360	} finally {	365	} finally {
361	stopDeltas();	366	if(checkDelta) stopDeltas();
362	}	367	}
363	}	368	}
364	}	369	}




			assertTrue("moved from handle should be original", destDelta.getMovedFromElement().equals(e.getParent()));
		} else {
			assertTrue("Destination container not changed", destDelta != null && deltaChildrenChanged(destDelta));
			IJavaElementDelta[] deltas = force ? destDelta.getChangedChildren() : destDelta.getAddedChildren();
			assertTrue("Added children not correct for element rename", deltas.length > i && deltas[i].getElement().equals(renamed));
			assertTrue("kind should be K_ADDED", deltas[i].getKind() == (force? IJavaElementDelta.CHANGED : IJavaElementDelta.ADDED));
			deltas = destDelta.getRemovedChildren();
			assertTrue("Removed children not correct for element rename", deltas.length > i && deltas[i].getElement().equals(e));
			assertTrue("kind should be K_REMOVED", deltas[i].getKind() == IJavaElementDelta.REMOVED);


	assertDeltas(
		"Unexpected deltas",
		"P[*]: {CHILDREN}\n" + 
				"	src[*]: {CHILDREN}\n" + 
				"		<default>[*]: {CHILDREN}\n" + 
				"			X.java[-]: {MOVED_TO(Y.java [in <default> [in src [in P]]])}\n" + 
				"			Y.java[*]: {CHILDREN | FINE GRAINED | PRIMARY RESOURCE}\n" + 
				"				Y[+]: {MOVED_FROM(X [in X.java [in <default> [in src [in P]]]])}"
	);
}
/*

Lines 357-363 Link Here

(-)a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/core/CopyResourceElementsOperation.java (-1 / +6 lines)
357	}	357	}
358		358
359	// register the correct change deltas	359	// register the correct change deltas
360	prepareDeltas(source, destCU, isMove());	360	boolean overWrite = this.force && destFile.exists();
		361	if (overWrite)
		362	getDeltaFor(dest.getJavaProject()).changed(destCU, IJavaElementDelta.F_CONTENT);
		363	else
		364	prepareDeltas(source, destCU, isMove());
		365
361	if (newCUName != null) {	366	if (newCUName != null) {
362	//the main type has been renamed	367	//the main type has been renamed
363	String oldName = Util.getNameWithoutJavaLikeExtension(source.getElementName());	368	String oldName = Util.getNameWithoutJavaLikeExtension(source.getElementName());

Return to bug 362711

Lines 80-86 Link Here

(-)a/org.eclipse.jdt.core.tests.model/src/org/eclipse/jdt/core/tests/model/CopyMoveResourcesTests.java (-37 / +70 lines)
80	}	80	}
81	IJavaElementDelta destDelta = this.deltaListener.getDeltaFor(container, true);	81	IJavaElementDelta destDelta = this.deltaListener.getDeltaFor(container, true);
82	assertTrue("Destination container not changed", destDelta != null && destDelta.getKind() == IJavaElementDelta.CHANGED);	82	assertTrue("Destination container not changed", destDelta != null && destDelta.getKind() == IJavaElementDelta.CHANGED);
83	IJavaElementDelta[] deltas = destDelta.getAddedChildren();	83	IJavaElementDelta[] deltas = null;
		84	if (force) {
		85	deltas = destDelta.getChangedChildren();
		86	}
		87	else {
		88	deltas = destDelta.getAddedChildren();
		89	}
84	// FIXME: not strong enough	90	// FIXME: not strong enough
85	boolean found = false;	91	boolean found = false;
86	for (int i = 0; i < deltas.length; i++) {	92	for (int i = 0; i < deltas.length; i++) {
Lines 809-833 Link Here
809	* existing CU.	815	* existing CU.
810	*/	816	*/
811	public void testMoveCU03() throws CoreException {	817	public void testMoveCU03() throws CoreException {
812	this.createFolder("/P/src/p1");	818	try {
813	this.createFile(	819	this.createFolder("/P/src/p1");
814	"/P/src/p1/X.java",	820	this.createFile(
815	"package p1;\n" +	821	"/P/src/p1/X.java",
816	"public class X {\n" +	822	"package p1;\n" +
817	"}"	823	"public class X {\n" +
818	);	824	"}"
819	ICompilationUnit cuSource = getCompilationUnit("/P/src/p1/X.java");	825	);
		826	ICompilationUnit cuSource = getCompilationUnit("/P/src/p1/X.java");
820		827
821	this.createFolder("/P/src/p2");	828	this.createFolder("/P/src/p2");
822	this.createFile(	829	this.createFile(
823	"/P/src/p2/X.java",	830	"/P/src/p2/X.java",
824	"package p2;\n" +	831	"package p2;\n" +
825	"public class X {\n" +	832	"public class X {\n" +
826	"}"	833	"}"
827	);	834	);
828	IPackageFragment pkgDest = getPackage("/P/src/p2");	835	IPackageFragment pkgDest = getPackage("/P/src/p2");
829		836	startDeltas();
830	movePositive(cuSource, pkgDest, null, null, true);	837	movePositive(new IJavaElement[] {cuSource}, new IJavaElement[] {pkgDest}, null, null, true, false, null);
		838	assertDeltas(
		839	"Incorrect delta",
		840	"P[*]: {CHILDREN}\n"
		841	+ " src[*]: {CHILDREN}\n"
		842	+ " p1[*]: {CHILDREN}\n"
		843	+ " X.java[-]: {MOVED_TO(X.java [in p2 [in src [in P]]])}\n"
		844	+ " p2[*]: {CHILDREN}\n"
		845	+ " X.java[*]: {CONTENT \| PRIMARY RESOURCE}");
		846	}
		847	finally {
		848	stopDeltas();
		849	}
831	}	850	}
832	/**	851	/**
833	* Ensures that a CU can be moved to a different package,	852	* Ensures that a CU can be moved to a different package,
Lines 853-877 Link Here
853	* be renamed, overwriting an existing resource.	872	* be renamed, overwriting an existing resource.
854	*/	873	*/
855	public void testMoveCU05() throws CoreException {	874	public void testMoveCU05() throws CoreException {
856	this.createFolder("/P/src/p1");	875	try {
857	this.createFile(	876	this.createFolder("/P/src/p1");
858	"/P/src/p1/X.java",	877	this.createFile(
859	"package p1;\n" +	878	"/P/src/p1/X.java",
860	"public class X {\n" +	879	"package p1;\n" +
861	"}"	880	"public class X {\n" +
862	);	881	"}"
863	ICompilationUnit cuSource = getCompilationUnit("/P/src/p1/X.java");	882	);
		883	ICompilationUnit cuSource = getCompilationUnit("/P/src/p1/X.java");
864		884
865	this.createFolder("/P/src/p2");	885	this.createFolder("/P/src/p2");
866	this.createFile(	886	this.createFile(
867	"/P/src/p2/Y.java",	887	"/P/src/p2/Y.java",
868	"package p2;\n" +	888	"package p2;\n" +
869	"public class Y {\n" +	889	"public class Y {\n" +
870	"}"	890	"}"
871	);	891	);
872	IPackageFragment pkgDest = getPackage("/P/src/p2");	892	IPackageFragment pkgDest = getPackage("/P/src/p2");
873		893	startDeltas();
874	movePositive(cuSource, pkgDest, null, "Y.java", true);	894	movePositive(new IJavaElement[] {cuSource}, new IJavaElement[] {pkgDest}, null, new String[]{"Y.java"}, true, false, null);
		895	assertDeltas(
		896	"Incorrect delta",
		897	"P[*]: {CHILDREN}\n"
		898	+ " src[*]: {CHILDREN}\n"
		899	+ " p1[*]: {CHILDREN}\n"
		900	+ " X.java[-]: {MOVED_TO(Y.java [in p2 [in src [in P]]])}\n"
		901	+ " p2[*]: {CHILDREN}\n"
		902	+ " Y.java[*]: {CHILDREN \| FINE GRAINED \| PRIMARY RESOURCE}\n"
		903	+ " Y[+]: {MOVED_FROM(X [in X.java [in p1 [in src [in P]]]])}");
		904	}
		905	finally {
		906	stopDeltas();
		907	}
875	}	908	}
876	/**	909	/**
877	* Ensures that a CU cannot be moved to a different package, replacing an	910	* Ensures that a CU cannot be moved to a different package, replacing an