Attachment #18739 for bug #70135

Lines 5-8 Link Here

(-)resources/ChangeSignature/canModify/A_test15_out.java (+6 lines)
5	private void foo(){	5	private void foo(){
6	m(true, 2);	6	m(true, 2);
7	}	7	}
		8	/**
		9	* @deprecated use instead m(boolean b, int i)
		10	*/
		11	private void m(int i, boolean b) {
		12	m(b, i);
		13	}
8	}	14	}

Lines 5-14 Link Here

(-)resources/ChangeSignature/canModify/A_test16_out.java (+13 lines)
5	private void foo(){	5	private void foo(){
6	m(true, 2);	6	m(true, 2);
7	}	7	}
		8	/**
		9	* @deprecated use instead m(boolean b, int i)
		10	*/
		11	protected void m(int i, boolean b) {
		12	m(b, i);
		13	}
8	}	14	}
9	class B extends A{	15	class B extends A{
10	protected void m(boolean b, int j){	16	protected void m(boolean b, int j){
11	m(false, 6);	17	m(false, 6);
12	super.m(true, 4);	18	super.m(true, 4);
		19	}
		20
		21	/**
		22	* @deprecated use instead m(boolean b, int j)
		23	*/
		24	protected void m(int j, boolean b) {
		25	m(b, j);
13	}	26	}
14	}	27	}

Lines 6-18 Link Here

(-)resources/ChangeSignature/canModify/A_test17_out.java (+18 lines)
6	private void foo(){	6	private void foo(){
7	m(true, 2);	7	m(true, 2);
8	}	8	}
		9	/**
		10	* @deprecated use instead m(boolean b, int i)
		11	*/
		12	public void m(int i, boolean b) {
		13	m(b, i);
		14	}
9	}	15	}
10	class B extends A1{	16	class B extends A1{
11	public void m(boolean b, int j){	17	public void m(boolean b, int j){
12	m(false, 6);	18	m(false, 6);
13	super.m(true, 4);	19	super.m(true, 4);
14	}	20	}
		21
		22	/**
		23	* @deprecated use instead m(boolean b, int j)
		24	*/
		25	public void m(int j, boolean b) {
		26	m(b, j);
		27	}
15	}	28	}
16	interface A {	29	interface A {
17	public void m(boolean b, int i);	30	public void m(boolean b, int i);
		31
		32	/**
		33	* @deprecated use instead m(boolean b, int i)
		34	*/
		35	public void m(int i, boolean b);
18	}	36	}

Lines 6-21 Link Here

(-)resources/ChangeSignature/canModify/A_test18_out.java (+23 lines)
6	private void foo(){	6	private void foo(){
7	m(true, 2);	7	m(true, 2);
8	}	8	}
		9	/**
		10	* @deprecated use instead m(boolean b, int i)
		11	*/
		12	public void m(int i, boolean b) {
		13	m(b, i);
		14	}
9	}	15	}
10	class B extends A1 implements AA{	16	class B extends A1 implements AA{
11	public void m(boolean b, int j){	17	public void m(boolean b, int j){
12	m(false, 6);	18	m(false, 6);
13	super.m(true, 4);	19	super.m(true, 4);
14	}	20	}
		21
		22	/**
		23	* @deprecated use instead m(boolean b, int j)
		24	*/
		25	public void m(int j, boolean b) {
		26	m(b, j);
		27	}
15	}	28	}
16	interface A {	29	interface A {
17	public void m(boolean b, int i);	30	public void m(boolean b, int i);
		31
		32	/**
		33	* @deprecated use instead m(boolean b, int i)
		34	*/
		35	public void m(int i, boolean b);
18	}	36	}
19	interface AA {	37	interface AA {
20	public void m(boolean yyy, int xxx);	38	public void m(boolean yyy, int xxx);
		39
		40	/**
		41	* @deprecated use instead m(boolean yyy, int xxx)
		42	*/
		43	public void m(int xxx, boolean yyy);
21	}	44	}

Lines 2-5 Link Here

(-)resources/ChangeSignature/canModify/A_test19_in.java (-1 / +1 lines)
2		2
3	class A {	3	class A {
4	public void m(int i, final boolean b){}	4	public void m(int i, final boolean b){}
5	}	5	}

Lines 2-5 Link Here

(-)resources/ChangeSignature/canModify/A_test19_out.java (-1 / +8 lines)
2		2
3	class A {	3	class A {
4	public void m(final boolean b, int i){}	4	public void m(final boolean b, int i){}
5	}	5
		6	/**
		7	* @deprecated use instead m(boolean b, int i)
		8	*/
		9	public void m(int i, final boolean b) {
		10	m(b, i);
		11	}
		12	}

Lines 2-5 Link Here

(-)resources/ChangeSignature/canModify/A_test20_out.java (+7 lines)
2		2
3	class A {	3	class A {
4	void m(int b[], int a){}	4	void m(int b[], int a){}
		5
		6	/**
		7	* @deprecated use instead m(int[] b, int a)
		8	*/
		9	void m(int a, int b[]) {
		10	m(b, a);
		11	}
5	}	12	}

Lines 13-18 Link Here

(-)resources/ChangeSignature/canModify/A_test27_out.java (+7 lines)
13	PoolMessageEvent( String msg, Object xml, int id, Object newParam ) {	13	PoolMessageEvent( String msg, Object xml, int id, Object newParam ) {
14	//empty	14	//empty
15	}	15	}
		16
		17	/**
		18	* @deprecated use instead PoolMessageEvent(String msg, Object xml, int id, Object newParam)
		19	*/
		20	PoolMessageEvent(String msg, Object xml, int id) {
		21	this(msg, xml, id, null);
		22	}
16	}	23	}
17	}	24	}
18		25

Lines 2-5 Link Here

(-)resources/ChangeSignature/canModify/A_testAdd28_out.java (+7 lines)
2	class A{	2	class A{
3	private void m(int i, int x){	3	private void m(int i, int x){
4	}	4	}
		5
		6	/**
		7	* @deprecated use instead m(int i, int x)
		8	*/
		9	private void m(int i) {
		10	m(i, 0);
		11	}
5	}	12	}

Lines 2-5 Link Here

(-)resources/ChangeSignature/canModify/A_testAdd29_out.java (+7 lines)
2	class A{	2	class A{
3	private void m(int x, int i){	3	private void m(int x, int i){
4	}	4	}
		5
		6	/**
		7	* @deprecated use instead m(int x, int i)
		8	*/
		9	private void m(int i) {
		10	m(0, i);
		11	}
5	}	12	}

Lines 3-6 Link Here

(-)resources/ChangeSignature/canModify/A_testAdd30_out.java (+7 lines)
3	private void m(int i, int x){	3	private void m(int i, int x){
4	m(i, x);	4	m(i, x);
5	}	5	}
		6
		7	/**
		8	* @deprecated use instead m(int i, int x)
		9	*/
		10	private void m(int i) {
		11	m(i, 0);
		12	}
6	}	13	}

Lines 3-13 Link Here

(-)resources/ChangeSignature/canModify/A_testAdd31_out.java (+14 lines)
3	void m(int i, int x){	3	void m(int i, int x){
4	m(i, x);	4	m(i, x);
5	}	5	}
		6
		7	/**
		8	* @deprecated use instead m(int i, int x)
		9	*/
		10	void m(int i) {
		11	m(i, 0);
		12	}
6	}	13	}
7	class B extends A{	14	class B extends A{
8	void m(int j, int x){	15	void m(int j, int x){
9	super.m(j, x);	16	super.m(j, x);
10	this.m(j, x);	17	this.m(j, x);
11	m(j, x);	18	m(j, x);
		19	}
		20
		21	/**
		22	* @deprecated use instead m(int j, int x)
		23	*/
		24	void m(int j) {
		25	m(j, 0);
12	}	26	}
13	}	27	}

Lines 3-6 Link Here

(-)resources/ChangeSignature/canModify/A_testAdd32_out.java (+7 lines)
3	private void m(int x, int i){	3	private void m(int x, int i){
4	m(x, i);	4	m(x, i);
5	}	5	}
		6
		7	/**
		8	* @deprecated use instead m(int x, int i)
		9	*/
		10	private void m(int i) {
		11	m(0, i);
		12	}
6	}	13	}

Lines 3-6 Link Here

(-)resources/ChangeSignature/canModify/A_testAdd33_out.java (+7 lines)
3	private void m(int x){	3	private void m(int x){
4	m(x);	4	m(x);
5	}	5	}
		6
		7	/**
		8	* @deprecated use instead m(int x)
		9	*/
		10	private void m() {
		11	m(0);
		12	}
6	}	13	}

Lines 3-26 Link Here

(-)resources/ChangeSignature/canModify/A_testAddRecursive1_out.java (+48 lines)
3	class A {	3	class A {
4	int i;	4	int i;
5	void m(int i, boolean bool) {this.i = i;}	5	void m(int i, boolean bool) {this.i = i;}
		6	/**
		7	* @deprecated use instead m(int i, boolean bool)
		8	*/
		9	void m(int i) {
		10	m(i, true);
		11	}
6	}	12	}
7	class Super extends A {	13	class Super extends A {
8	void m(int i, boolean bool) { super.m(1, bool); }	14	void m(int i, boolean bool) { super.m(1, bool); }
		15
		16	/**
		17	* @deprecated use instead m(int i, boolean bool)
		18	*/
		19	void m(int i) {
		20	m(i, true);
		21	}
9	}	22	}
10	class Recursive extends A {	23	class Recursive extends A {
11	void m(int i, boolean bool) { if (true) m(i, bool); }	24	void m(int i, boolean bool) { if (true) m(i, bool); }
		25
		26	/**
		27	* @deprecated use instead m(int i, boolean bool)
		28	*/
		29	void m(int i) {
		30	m(i, true);
		31	}
12	}	32	}
13	class ThisRecursive extends A {	33	class ThisRecursive extends A {
14	void m(int i, boolean bool) { this.m(i, bool); }	34	void m(int i, boolean bool) { this.m(i, bool); }
		35
		36	/**
		37	* @deprecated use instead m(int i, boolean bool)
		38	*/
		39	void m(int i) {
		40	m(i, true);
		41	}
15	}	42	}
16	class AlmostRecursive extends A {	43	class AlmostRecursive extends A {
17	void m(int i, boolean bool) { new A().m(i, true); }	44	void m(int i, boolean bool) { new A().m(i, true); }
		45
		46	/**
		47	* @deprecated use instead m(int i, boolean bool)
		48	*/
		49	void m(int i) {
		50	m(i, true);
		51	}
18	}	52	}
19	class RecursiveOrNot extends A {	53	class RecursiveOrNot extends A {
20	void m(int i, boolean bool) { new RecursiveOrNot().m(i, bool); }	54	void m(int i, boolean bool) { new RecursiveOrNot().m(i, bool); }
		55
		56	/**
		57	* @deprecated use instead m(int i, boolean bool)
		58	*/
		59	void m(int i) {
		60	m(i, true);
		61	}
21	}	62	}
22	class NonRecursive extends A {	63	class NonRecursive extends A {
23	void m(int i, boolean bool) { int k= i; }	64	void m(int i, boolean bool) { int k= i; }
		65
		66	/**
		67	* @deprecated use instead m(int i, boolean bool)
		68	*/
		69	void m(int i) {
		70	m(i, true);
		71	}
24	}	72	}
25	class Calling extends A {	73	class Calling extends A {
26	void bar() { m(17, true); }	74	void bar() { m(17, true); }

Lines 3-6 Link Here

(-)resources/ChangeSignature/canModify/A_testAddReorderRename34_out.java (+7 lines)
3	private int m(boolean jj, Object x, int i){	3	private int m(boolean jj, Object x, int i){
4	return m(false, x, m(jj, x, i));	4	return m(false, x, m(jj, x, i));
5	}	5	}
		6
		7	/**
		8	* @deprecated use instead m(boolean j, Object x, int iii)
		9	*/
		10	private int m(int iii, boolean j) {
		11	return m(j, null, iii);
		12	}
6	}	13	}

Lines 3-6 Link Here

(-)resources/ChangeSignature/canModify/A_testAll41_out.java (+7 lines)
3	void m(){	3	void m(){
4	m();	4	m();
5	}	5	}
		6
		7	/**
		8	* @deprecated use instead m()
		9	*/
		10	void m(int i) {
		11	m();
		12	}
6	}	13	}

Lines 3-6 Link Here

(-)resources/ChangeSignature/canModify/A_testAll43_out.java (+7 lines)
3	void m(int j){	3	void m(int j){
4	m(1);	4	m(1);
5	}	5	}
		6
		7	/**
		8	* @deprecated use instead m(int j)
		9	*/
		10	void m(int i, int j) {
		11	m(j);
		12	}
6	}	13	}

Lines 3-6 Link Here

(-)resources/ChangeSignature/canModify/A_testAll44_out.java (+7 lines)
3	boolean m(int j){	3	boolean m(int j){
4	m(1);	4	m(1);
5	}	5	}
		6
		7	/**
		8	* @deprecated use instead m(int j)
		9	*/
		10	public void m(int i, int j) {
		11	m(j);
		12	}
6	}	13	}

Lines 3-6 Link Here

(-)resources/ChangeSignature/canModify/A_testAll45_out.java (+7 lines)
3	void m(boolean j){	3	void m(boolean j){
4	m(1);	4	m(1);
5	}	5	}
		6
		7	/**
		8	* @deprecated use instead m(boolean j)
		9	*/
		10	public void m(int i, int j) {
		11	m(j); // but what if the other direction - was value, now void?
		12	}
6	}	13	}

Lines 15-18 Link Here

(-)resources/ChangeSignature/canModify/A_testEnum04_in.java (-1 / +1 lines)
15	{	15	{
16	A a= A.GREEN.getNext();	16	A a= A.GREEN.getNext();
17	}	17	}
18	}	18	}

Lines 15-18 Link Here

(-)resources/ChangeSignature/canModify/A_testEnum04_out.java (-1 / +1 lines)
15	{	15	{
16	A a= A.GREEN.getNext(true);	16	A a= A.GREEN.getNext(true);
17	}	17	}
18	}	18	}

Lines 2-11 Link Here

(-)resources/ChangeSignature/canModify/A_testGenerics01_out.java (+14 lines)
2		2
3	class A<E> {	3	class A<E> {
4	void m(E e, Integer integer) {}	4	void m(E e, Integer integer) {}
		5
		6	/**
		7	* @deprecated use instead m(E e, Integer integer)
		8	*/
		9	public void m(Integer integer, E e) {
		10	m(e, integer);
		11	}
5	}	12	}
6		13
7	class Sub<Q> extends A<Q> {	14	class Sub<Q> extends A<Q> {
8	void m(Q q, Integer integer) {	15	void m(Q q, Integer integer) {
9	super.m(q, integer);	16	super.m(q, integer);
		17	}
		18
		19	/**
		20	* @deprecated use instead m(Q q, Integer integer)
		21	*/
		22	public void m(Integer integer, Q q) {
		23	m(q, integer);
10	}	24	}
11	}	25	}

Lines 5-12 Link Here

(-)resources/ChangeSignature/canModify/A_testGenerics02_out.java (+14 lines)
5		5
6	class A<E> {	6	class A<E> {
7	<T> void m(E e, T t, List<HashMap> maps) {}	7	<T> void m(E e, T t, List<HashMap> maps) {}
		8
		9	/**
		10	* @deprecated use instead m(E e, Integer integer, List<HashMap> maps)
		11	*/
		12	public void m(T t, E e) {
		13	m(e, t, null);
		14	}
8	}	15	}
9		16
10	class Sub<Q> extends A<Q> {	17	class Sub<Q> extends A<Q> {
11	void m(Q q, Integer i, List<HashMap> maps) {}	18	void m(Q q, Integer i, List<HashMap> maps) {}
		19
		20	/**
		21	* @deprecated use instead m(Q q, Integer integer, List<HashMap> maps)
		22	*/
		23	public void m(Integer i, Q q) {
		24	m(q, i, null);
		25	}
12	}	26	}

Lines 4-9 Link Here

(-)resources/ChangeSignature/canModify/A_testName01_out.java (+7 lines)
4	void newName(String y){	4	void newName(String y){
5	newName(y);	5	newName(y);
6	}	6	}
		7
		8	/**
		9	* @deprecated use instead newName(String y)
		10	*/
		11	void m(String y) {
		12	newName(y);
		13	}
7	}	14	}
8		15
9	class B {	16	class B {

Lines 4-14 Link Here

(-)resources/ChangeSignature/canModify/A_testName02_out.java (+14 lines)
4	void newName(String y){	4	void newName(String y){
5	newName(y);	5	newName(y);
6	}	6	}
		7
		8	/**
		9	* @deprecated use instead newName(String y)
		10	*/
		11	void m(String y) {
		12	newName(y);
		13	}
7	}	14	}
8		15
9	class B extends A {	16	class B extends A {
10	public void newName(String q) {	17	public void newName(String q) {
11	new A().newName("x");	18	new A().newName("x");
12	return newName("k");	19	return newName("k");
		20	}
		21
		22	/**
		23	* @deprecated use instead newName(String q)
		24	*/
		25	public void m(String q) {
		26	newName(q);
13	}	27	}
14	}	28	}

Lines 3-7 Link Here

(-)resources/ChangeSignature/canModify/A_testRenameReorder26_in.java (+1 lines)
3	class A{	3	class A{
4	private void m(boolean y, int a){	4	private void m(boolean y, int a){
5	m(y, a);	5	m(y, a);
		6	m(y, a);
6	}	7	}
7	}	8	}

Lines 3-7 Link Here

(-)resources/ChangeSignature/canModify/A_testRenameReorder26_out.java (+9 lines)
3	class A{	3	class A{
4	private void m(int bb, boolean zzz){	4	private void m(int bb, boolean zzz){
5	m(bb, zzz);	5	m(bb, zzz);
		6	m(bb, zzz);
6	}	7	}
		8
		9	/**
		10	* @deprecated use instead m(int a, boolean y)
		11	*/
		12	private void m(boolean y, int a) {
		13	m(y, a);
		14	m(y, a);
		15	}
7	}	16	}

Lines 3-7 Link Here

(-)resources/ChangeSignature/canModify/A_testRenameReorder27_in.java (+1 lines)
3	class A{	3	class A{
4	private void m(boolean y, int a){	4	private void m(boolean y, int a){
5	m(y, a);	5	m(y, a);
		6	m(y, a);
6	}	7	}
7	}	8	}

Lines 1-7 Link Here

(-)resources/ChangeSignature/canModify/A_testRenameReorder27_out.java (-2 / +11 lines)
1	package p;	1	package p;
2		2
3	class A{	3	class A{
4	private void m(int a, boolean yyy){	4	private void m(int y, boolean a){
5	m(a, yyy);	5	m(y, a);
		6	m(y, a);
6	}	7	}
		8
		9	/**
		10	* @deprecated use instead m(int a, boolean y)
		11	*/
		12	private void m(boolean y, int a) {
		13	m(y, a);
		14	m(y, a);
		15	}
7	}	16	}

Lines 6-11 Link Here

(-)resources/ChangeSignature/canModify/A_testVararg02_out.java (+14 lines)
6	System.out.println(name);	6	System.out.println(name);
7	}	7	}
8	}	8	}
		9
		10	/**
		11	* @deprecated use instead m(Object o, int i, String... names)
		12	*/
		13	public void m(int i, String... names) {
		14	m(new Object(), i, names);
		15	}
9	}	16	}
10		17
11	class B extends A {	18	class B extends A {
Lines 13-18 Link Here
13	for (String name : names) {	20	for (String name : names) {
14	System.out.println(name);	21	System.out.println(name);
15	}	22	}
		23	}
		24
		25	/**
		26	* @deprecated use instead m(Object o, int i, String... names)
		27	*/
		28	public void m(int i, String[] names) {
		29	m(new Object(), i, names);
16	}	30	}
17	}	31	}
18		32

Lines 17-20 Link Here

(-)resources/ChangeSignature/canModify/A_testVararg05_out.java (+7 lines)
17	use(null);	17	use(null);
18	use(null);	18	use(null);
19	}	19	}
		20
		21	/**
		22	* @deprecated use instead use(Object first)
		23	*/
		24	public void use(Object first, String... args) {
		25	use(first);
		26	}
20	}	27	}

Lines 3-12 Link Here

(-)resources/ChangeSignature/canModify/A_testVararg07_out.java (+14 lines)
3	class A {	3	class A {
4	public void m(int i, String j, Integer k) {	4	public void m(int i, String j, Integer k) {
5	}	5	}
		6
		7	/**
		8	* @deprecated use instead m(int i, String j, Integer k)
		9	*/
		10	public void m(int i, String[] names) {
		11	m(i, "none", 17);
		12	}
6	}	13	}
7		14
8	class B extends A {	15	class B extends A {
9	public void m(int i, String j, Integer k) {	16	public void m(int i, String j, Integer k) {
		17	}
		18
		19	/**
		20	* @deprecated use instead m(int i, String j, Integer k)
		21	*/
		22	public void m(int i, String... names) {
		23	m(i, "none", 17);
10	}	24	}
11	}	25	}
12		26




/*******************************************************************************
 * Copyright (c) 2000, 2005 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.jdt.ui.tests.refactoring;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;

import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.dom.Modifier;

import org.eclipse.jdt.internal.corext.refactoring.ExceptionInfo;

		return fileName + ".java"; 
	}
	
	private String getTestFileName(boolean canReorder, boolean input, boolean leaveStub){
		String fileName= TEST_PATH_PREFIX + getRefactoringPath();
		fileName += (canReorder ? "canModify/": "cannotModify/");
		return fileName + getSimpleTestFileName(canReorder, input);
	}
		
	//---helpers 

	protected ICompilationUnit createCUfromTestFile(IPackageFragment pack, boolean canRename, boolean input) throws Exception {
		return createCUfromTestFile(pack, canRename, input, false);
	}

	protected ICompilationUnit createCUfromTestFile(IPackageFragment pack, boolean canRename, boolean input, boolean leaveStub) throws Exception {
		return createCU(pack, getSimpleTestFileName(canRename, input), getFileContents(getTestFileName(canRename, input, leaveStub)));
	}

	private static ParameterInfo[] createNewParamInfos(String[] newTypes, String[] newNames, String[] newDefaultValues) {

			list.add(newIndices[i], newParamInfos[i]);
		}
	}
	
	private void helperAdd(String[] signature, ParameterInfo[] newParamInfo, int[] newIndices) throws Exception {
		helperAdd(signature, newParamInfo, newIndices, false, true);
	}		
	
	private void helperAdd(String[] signature, ParameterInfo[] newParamInfo, int[] newIndices, boolean leaveStub) throws Exception {
		helperAdd(signature, newParamInfo, newIndices, leaveStub, true);
	}

	private void helperAdd(String[] signature, ParameterInfo[] newParamInfos, int[] newIndices, boolean leaveStub, boolean propogateChanges) throws Exception {
		ICompilationUnit cu= createCUfromTestFile(getPackageP(), true, true);
		IType classA= getType(cu, "A");
		IMethod method = classA.getMethod("m", signature);
		assertTrue("method does not exist", method.exists());
		ChangeSignatureRefactoring ref= ChangeSignatureRefactoring.create(method);
		addInfos(ref.getParameterInfos(), newParamInfos, newIndices);
		ref.setLeaveStub(leaveStub);
		ref.setTagAsDeprecated(propogateChanges);
		ref.setUpdateReferences(propogateChanges);
		RefactoringStatus result= performRefactoring(ref);
		assertEquals("precondition was supposed to pass", null, result);
		

		String newCuName= getSimpleTestFileName(true, true);
		ICompilationUnit newcu= pack.getCompilationUnit(newCuName);
		assertTrue(newCuName + " does not exist", newcu.exists());
		String expectedFileContents= getFileContents(getTestFileName(true, false, false));
		assertEqualLines("invalid renaming", expectedFileContents, newcu.getSource());
	}
	
	/*
	 * Rename method 'A.m(signature)' to 'A.newMethodName(signature)'
	 */
	private void helperRenameMethod(String[] signature, String newMethodName, boolean leaveStub) throws Exception {
		ICompilationUnit cu= createCUfromTestFile(getPackageP(), true, true);
		IType classA= getType(cu, "A");
		IMethod method = classA.getMethod("m", signature);
		assertTrue("method m does not exist in A", method.exists());
		ChangeSignatureRefactoring ref= ChangeSignatureRefactoring.create(method);
		ref.setLeaveStub(leaveStub);
		ref.setNewMethodName(newMethodName);
		RefactoringStatus result= performRefactoring(ref);
		assertEquals("precondition was supposed to pass", null, result);

		String newCuName= getSimpleTestFileName(true, true);
		ICompilationUnit newcu= pack.getCompilationUnit(newCuName);
		assertTrue(newCuName + " does not exist", newcu.exists());
		String expectedFileContents= getFileContents(getTestFileName(true, false, false));
		assertEqualLines("invalid change of method name", expectedFileContents, newcu.getSource());
	}

	private void helperDoAll(String typeName, 
			String methodName, 
		  	String[] signature, 
		  	ParameterInfo[] newParamInfos, 
		  	int[] newIndices, 
		  	String[] oldParamNames, 
		  	String[] newParamNames, 
		  	String[] newParameterTypeNames, 
		  	int[] permutation,
		  	int newVisibility,
		  	int[] deleted, String returnTypeName) throws Exception {
		helperDoAll( typeName, 
				methodName, 
			  	signature, 
			  	newParamInfos, 
			  	newIndices, 
			  	oldParamNames, 
			  	newParamNames, 
			  	newParameterTypeNames, 
			  	permutation,
			  	newVisibility,
			  	deleted, returnTypeName, false, false, true);
	}
	
	private void helperDoAll(String typeName, 
								String methodName, 
							  	String[] signature, 
							  	ParameterInfo[] newParamInfos, 

							  	String[] newParameterTypeNames, 
							  	int[] permutation,
							  	int newVisibility,
							  	int[] deleted, String returnTypeName,
							  	boolean leaveStub, 
							  	boolean leaveBody, boolean updateReferences)  throws Exception{
		ICompilationUnit cu= createCUfromTestFile(getPackageP(), true, true, leaveStub);
		IType classA= getType(cu, typeName);
		IMethod method = classA.getMethod(methodName, signature);
		assertTrue("method " + methodName +" does not exist", method.exists());

		modifyInfos(ref.getParameterInfos(), newParamInfos, newIndices, oldParamNames, newParamNames, newParameterTypeNames, permutation);
		if (newVisibility != JdtFlags.VISIBILITY_CODE_INVALID)
			ref.setVisibility(newVisibility);
		ref.setLeaveStub(leaveStub);
		ref.setLeaveBody(leaveBody);
		ref.setUpdateReferences(updateReferences);
		ref.setTagAsDeprecated(updateReferences);
		RefactoringStatus result= performRefactoring(ref);
		assertEquals("precondition was supposed to pass", null, result);
		

		String newCuName= getSimpleTestFileName(true, true);
		ICompilationUnit newcu= pack.getCompilationUnit(newCuName);
		assertTrue(newCuName + " does not exist", newcu.exists());
		String expectedFileContents= getFileContents(getTestFileName(true, false, leaveStub));
		assertEqualLines(expectedFileContents, newcu.getSource());
	}
	

	}
	
	private void helper1(String[] newOrder, String[] signature, String[] oldNames, String[] newNames) throws Exception{
		helper1(newOrder, signature, oldNames, newNames, false);
	}

	private void helper1(String[] newOrder, String[] signature, String[] oldNames, String[] newNames, boolean leaveStub) throws Exception, JavaModelException, IOException {
		helper1(newOrder, signature, oldNames, newNames, leaveStub, false);
	}
	
	private void helper1(String[] newOrder, String[] signature, String[] oldNames, String[] newNames, boolean leaveStub, boolean leaveBody) throws Exception, JavaModelException, IOException {
		ICompilationUnit cu= createCUfromTestFile(getPackageP(), true, true);
		IType classA= getType(cu, "A");
		IMethod method = classA.getMethod("m", signature);
		assertTrue("method must exist", method.exists());
		ChangeSignatureRefactoring ref= ChangeSignatureRefactoring.create(method);
		modifyInfos(ref.getParameterInfos(), newOrder, oldNames, newNames);
		ref.setLeaveStub(leaveStub);
		ref.setLeaveBody(leaveBody);
		RefactoringStatus result= performRefactoring(ref);
		assertEquals("precondition was supposed to pass", null, result);
		
		IPackageFragment pack= (IPackageFragment)cu.getParent();
		String newCuName= getSimpleTestFileName(true, true);
		ICompilationUnit newcu= pack.getCompilationUnit(newCuName);
		assertTrue(newCuName + " does not exist", newcu.exists());
		String expectedFileContents= getFileContents(getTestFileName(true, false, leaveStub));
		//		assertEquals("invalid renaming", expectedFileContents, newcu.getSource());
		assertEqualLines(expectedFileContents, newcu.getSource());
	}


		String newCuName= getSimpleTestFileName(true, true);
		ICompilationUnit newcu= pack.getCompilationUnit(newCuName);
		assertTrue(newCuName + " does not exist", newcu.exists());
		String expectedFileContents= getFileContents(getTestFileName(true, false, false));
		assertEqualLines(expectedFileContents, newcu.getSource());
	}


		String newCuName= getSimpleTestFileName(true, true);
		ICompilationUnit newcu= pack.getCompilationUnit(newCuName);
		assertTrue(newCuName + " does not exist", newcu.exists());
		String expectedFileContents= getFileContents(getTestFileName(true, false, false));
		assertEqualLines("invalid renaming", expectedFileContents, newcu.getSource());
	}
	

	}
	
	public void test15() throws Exception{
		//helper1(new String[]{"b", "i"}, new String[]{"I", "Z"});
		helper1(new String[]{"b", "i"}, new String[]{"I", "Z"},null,null,true);
	}
	
	public void test16() throws Exception{
		helper1(new String[]{"b", "i"}, new String[]{"I", "Z"},null,null,true);
	}
	
	public void test17() throws Exception{
		//exception because of bug 11151
		//helper1(new String[]{"b", "i"}, new String[]{"I", "Z"});
		helper1(new String[]{"b", "i"}, new String[]{"I", "Z"},null,null,true);
	}
	
	public void test18() throws Exception{
		//exception because of bug 11151
		//helper1(new String[]{"b", "i"}, new String[]{"I", "Z"});
		helper1(new String[]{"b", "i"}, new String[]{"I", "Z"},null,null,true);
	}
	
	public void test19() throws Exception{
//		printTestDisabledMessage("bug 7274 - reorder parameters: incorrect when parameters have more than 1 modifiers");
		//helper1(new String[]{"b", "i"}, new String[]{"I", "Z"});
		helper1(new String[]{"b", "i"}, new String[]{"I", "Z"},null,null,true);
	}
	public void test20() throws Exception{
//		printTestDisabledMessage("bug 18147");
//		helper1(new String[]{"b", "i"}, new String[]{"I", "Z"});
		helper1(new String[]{"b", "a"}, new String[]{"I", "[I"},null,null,true);
	}

//constructor tests

		String newReturnTypeName= null;
		helperDoAll("A", "A", signature, newParamInfo, newIndices, oldParamNames, newParamNames, null, permutation, newVisibility, deleted, newReturnTypeName);
	}
	
	public void test22() throws Exception{
		if (! RUN_CONSTRUCTOR_TEST){
			printTestDisabledMessage("disabled for constructors for now");

		String newReturnTypeName= null;
		helperDoAll("A", "A", signature, newParamInfo, newIndices, oldParamNames, newParamNames, null, permutation, newVisibility, deleted, newReturnTypeName);
	}
	
	public void test23() throws Exception{
		if (! RUN_CONSTRUCTOR_TEST){
			printTestDisabledMessage("disabled for constructors for now");

		int newVisibility= JdtFlags.VISIBILITY_CODE_INVALID;//retain
		int[] deleted= null;
		String newReturnTypeName= null;
		helperDoAll("Query.PoolMessageEvent", "PoolMessageEvent", signature, newParamInfo, newIndices, oldParamNames, newParamNames, null, permutation, newVisibility, deleted, newReturnTypeName, true, false, true);
	}

	public void testRenameReorder26() throws Exception{
		helper1(new String[]{"a", "y"}, new String[]{"Z", "I"}, new String[]{"y", "a"}, new String[]{"zzz", "bb"}, true, true);
	}
	
	public void testRenameReorder27() throws Exception{
		helper1(new String[]{"a", "y"}, new String[]{"Z", "I"}, new String[]{"y", "a"}, new String[]{"a", "y"}, true, true);
	}

	public void testAdd28()throws Exception{

		String[] newDefaultValues= {"0"};
		ParameterInfo[] newParamInfo= createNewParamInfos(newTypes, newNames, newDefaultValues);
		int[] newIndices= {1};
		helperAdd(signature, newParamInfo, newIndices, true);
	}

	public void testAdd29()throws Exception{

		String[] newDefaultValues= {"0"};
		ParameterInfo[] newParamInfo= createNewParamInfos(newTypes, newNames, newDefaultValues);
		int[] newIndices= {0};
		helperAdd(signature, newParamInfo, newIndices, true);
	}

	public void testAdd30()throws Exception{

		String[] newDefaultValues= {"0"};
		ParameterInfo[] newParamInfo= createNewParamInfos(newTypes, newNames, newDefaultValues);
		int[] newIndices= {1};
		helperAdd(signature, newParamInfo, newIndices, true);
	}
	
	public void testAdd31()throws Exception{

		String[] newDefaultValues= {"0"};
		ParameterInfo[] newParamInfo= createNewParamInfos(newTypes, newNames, newDefaultValues);
		int[] newIndices= {1};
		helperAdd(signature, newParamInfo, newIndices, true);
	}

	public void testAdd32()throws Exception{

		String[] newDefaultValues= {"0"};
		ParameterInfo[] newParamInfo= createNewParamInfos(newTypes, newNames, newDefaultValues);
		int[] newIndices= {0};
		helperAdd(signature, newParamInfo, newIndices, true);
	}

	public void testAdd33()throws Exception{

		String[] newDefaultValues= {"0"};
		ParameterInfo[] newParamInfo= createNewParamInfos(newTypes, newNames, newDefaultValues);
		int[] newIndices= {0};
		helperAdd(signature, newParamInfo, newIndices, true);
	}

	public void testAddReorderRename34()throws Exception{

		int[] deletedIndices= null;
		int newVisibility= JdtFlags.VISIBILITY_CODE_INVALID;//retain
		String newReturnTypeName= null;
		helperDoAll("A", "m", signature, newParamInfo, newIndices, oldParamNames, newParamNames, null, permutation, newVisibility, deletedIndices, newReturnTypeName, true, false, true);
	}	

	public void testAll35()throws Exception{

		int[] deletedIndices= {0};
		int newVisibility= Modifier.NONE;
		String newReturnTypeName= null;
		helperDoAll("A", "m", signature, newParamInfo, newIndices, oldParamNames, newParamNames, null, permutation, newVisibility, deletedIndices, newReturnTypeName, true, false, true);
	}	

	public void testAll42()throws Exception{

		int[] deletedIndices= {0};
		int newVisibility= Modifier.NONE;
		String newReturnTypeName= null;
		helperDoAll("A", "m", signature, newParamInfo, newIndices, oldParamNames, newParamNames, null, permutation, newVisibility, deletedIndices, newReturnTypeName, true, false, true);
	}	

	public void testAll44()throws Exception{

			printTestDisabledMessage("disabled for constructors for now");
			return;
		}
		
		String[] signature= {};
		String[] newNames= {"i"};
		String[] newTypes= {"int"};

		helperDoAll("A", "A", signature, newParamInfo, newIndices, oldParamNames, newParamNames, null, permutation, newVisibility, deletedIndices, newReturnTypeName);
	}

	public void testAll46b()throws Exception{
		if (! RUN_CONSTRUCTOR_TEST){
			printTestDisabledMessage("disabled for constructors for now");
			return;
		}
		
		String[] signature= {};
		String[] newNames= {"i"};
		String[] newTypes= {"int"};
		String[] newDefaultValues= {"1"};
		ParameterInfo[] newParamInfo= createNewParamInfos(newTypes, newNames, newDefaultValues);
		int[] newIndices= {0};

		String[] oldParamNames= {};
		String[] newParamNames= {};
		int[] permutation= {0};
		int[] deletedIndices= null;
		int newVisibility= Modifier.NONE;
		String newReturnTypeName= null;
		helperDoAll("A", "A", signature, newParamInfo, newIndices, oldParamNames, newParamNames, null, permutation, newVisibility, deletedIndices, newReturnTypeName, true, false, false);
	}

	public void testAll47()throws Exception{
		if (! RUN_CONSTRUCTOR_TEST){
			printTestDisabledMessage("disabled for constructors for now");

		String[] newDefaultValues= {"true"};
		ParameterInfo[] newParamInfo= createNewParamInfos(newTypes, newNames, newDefaultValues);
		int[] newIndices= {1};
		helperAdd(signature, newParamInfo, newIndices, true, true);
	}

	public void testAddRecursive2()throws Exception{ 
		// As above, but don't update callers
		String[] signature= {"I"};
		String[] newNames= {"bool"};
		String[] newTypes= {"boolean"};
		String[] newDefaultValues= {"true"};
		ParameterInfo[] newParamInfo= createNewParamInfos(newTypes, newNames, newDefaultValues);
		int[] newIndices= {1};
		helperAdd(signature, newParamInfo, newIndices, true, false);
	}
	
	public void testException01() throws Exception {

	
	public void testName01() throws Exception {
		String[] signature= {"QString;"};
		helperRenameMethod(signature, "newName",true);
	}

	public void testName02() throws Exception {
		String[] signature= {"QString;"};
		helperRenameMethod(signature, "newName",true);
	}
	
	public void testFailImport01() throws Exception {

			printTestDisabledMessage("BUG_83319_CORE_REFS_IN_STATIC_IMPORT");
			return;
		}
		helperRenameMethod(new String[0], "abc", false);
	}
	
	public void testStaticImport02() throws Exception {

		int[] deletedIndices= {};
		int newVisibility= Modifier.PUBLIC;
		String newReturnTypeName= null;
		helperDoAll("A", "m", signature, newParamInfo, newIndices, oldParamNames, newParamNames, null, permutation, newVisibility, deletedIndices, newReturnTypeName, true, false, true);
	}
	
	public void testVararg03() throws Exception {

		String newReturnTypeName= null;
		helperDoAll("A", "use", signature, newParamInfo, newIndices, oldParamNames, newParamNames, null, permutation, newVisibility, deletedIndices, newReturnTypeName);
	}

	public void testVararg04b() throws Exception {
		String[] signature= {"[QString;"};
		String[] newNames= {"i"};
		String[] newTypes= {"int"};
		String[] newDefaultValues= {"1"};
		ParameterInfo[] newParamInfo= createNewParamInfos(newTypes, newNames, newDefaultValues);
		int[] newIndices= {0};

		String[] oldParamNames= {"args"};
		String[] newParamNames= {"args"};
		int[] permutation= {};
		int[] deletedIndices= {};
		int newVisibility= Modifier.PUBLIC;
		String newReturnTypeName= null;
		helperDoAll("A", "use", signature, newParamInfo, newIndices, oldParamNames, newParamNames, null, permutation, newVisibility, deletedIndices, newReturnTypeName, true, true, false);
	}
	
	public void testVararg05() throws Exception {
		String[] signature= {"QObject;", "[QString;"};

		int[] deletedIndices= {1};
		int newVisibility= Modifier.PUBLIC;
		String newReturnTypeName= null;
		helperDoAll("A", "use", signature, newParamInfo, newIndices, oldParamNames, newParamNames, null, permutation, newVisibility, deletedIndices, newReturnTypeName, true, false, true);
	}
	
	public void testVararg06() throws Exception {

		int[] deletedIndices= { 1 };
		int newVisibility= Modifier.PUBLIC;
		String newReturnTypeName= null;
		helperDoAll("A", "m", signature, newParamInfo, newIndices, oldParamNames, newParamNames, null, permutation, newVisibility, deletedIndices, newReturnTypeName, true, false, true);
	}
	
	public void testVararg08() throws Exception {

		int[] deletedIndices= { };
		int newVisibility= Modifier.NONE;
		String newReturnTypeName= null;
		helperDoAll("A", "m", signature, newParamInfo, newIndices, oldParamNames, newParamNames, newParameterTypeNames, permutation, newVisibility, deletedIndices, newReturnTypeName, true, false, true);
	}

	public void testGenerics03() throws Exception {

		helperDoAll("A", "m", signature, newParamInfo, newIndices, oldParamNames, newParamNames, newParameterTypeNames, permutation, newVisibility, deletedIndices, newReturnTypeName);
	}

	public void testGenerics05() throws Exception {
		if (true){
			printTestDisabledMessage("how to add old bindings?");
			return;
		}
		String[] signature= {"QT;", "QE;"};
		String[] newNames= {"maps"};
		String[] newTypes= {"java.util.List<HashMap>"};
		String[] newDefaultValues= {"null"};
		ParameterInfo[] newParamInfo= createNewParamInfos(newTypes, newNames, newDefaultValues);
		int[] newIndices= {2};

		String[] oldParamNames= {"e", "t"};
		String[] newParamNames= {"e", "t"};
		String[] newParameterTypeNames= null;
		int[] permutation= {1, 0, 2};
		int[] deletedIndices= { };
		int newVisibility= Modifier.NONE;
		String newReturnTypeName= null;
		helperDoAll("A", "m", signature, newParamInfo, newIndices, oldParamNames, newParamNames, newParameterTypeNames, permutation, newVisibility, deletedIndices, newReturnTypeName, true, false, true);
	}

	public void testGenerics06() throws Exception {
		if (true){
			printTestDisabledMessage("how to add old bindings?");
			return;
		}
		String[] signature= {"QList<QInteger;>;", "QA<QString;>;"};
		String[] newNames= {"li"};
		String[] newTypes= {"List<Integer>"};
		String[] newDefaultValues= {"null"};
		ParameterInfo[] newParamInfo= createNewParamInfos(newTypes, newNames, newDefaultValues);
		int[] newIndices= {2};

		String[] oldParamNames= {"li", "as"};
		String[] newParamNames= {"li", "as"};
		String[] newParameterTypeNames= null;
		int[] permutation= {1, 2, 0};
		int[] deletedIndices= {0};
		int newVisibility= Modifier.PUBLIC;
		String newReturnTypeName= null;
		helperDoAll("A", "m", signature, newParamInfo, newIndices, oldParamNames, newParamNames, newParameterTypeNames, permutation, newVisibility, deletedIndices, newReturnTypeName, true, false, true);
	}
}




package p;

class Super extends A {
	void m(int i) { super.m(1); }
}
class A {
	int i;
	void m(int i) {this.i = i;}
}
class Recursive extends A {
	void m(int i) { if (true) m(i); }
}
class ThisRecursive extends A {
	void m(int i) { this.m(i); }
}
class AlmostRecursive extends A {
	void m(int i) { new A().m(i); }
}
class RecursiveOrNot extends A {
	void m(int i) { new RecursiveOrNot().m(i); }
}
class NonRecursive extends A {
	void m(int i) { int k= i; }
}
class Calling extends A {
	void bar() { m(17);m(18); }
}
class Calling2 {
	void bar() { new A().m(17); }
}
class Calling3 {
	void bar() { new Recursive().m(17); }
}




package p;

class Super extends A {
	void m(int i) { super.m(1); }
}
class A {
	int i;
	void m(int i, boolean bool) {this.i = i;}
	void m(int i) {
		m(i, true);
	}
}
class Recursive extends A {
	void m(int i) { if (true) m(i); }
}
class ThisRecursive extends A {
	void m(int i) { this.m(i); }
}
class AlmostRecursive extends A {
	void m(int i) { new A().m(i); }
}
class RecursiveOrNot extends A {
	void m(int i) { new RecursiveOrNot().m(i); }
}
class NonRecursive extends A {
	void m(int i) { int k= i; }
}
class Calling extends A {
	void bar() { m(17);m(18); }
}
class Calling2 {
	void bar() { new A().m(17); }
}
class Calling3 {
	void bar() { new Recursive().m(17); }
}

Added Link Here

(-)resources/ChangeSignature/canModify/A_testAll46b_in.java (+11 lines)
1	package p;
2	class A{
3	A(){
4	}
5	void f(){
6	new A();
7	}
8	A(String a){
9	this();
10	}
11	}

Added Link Here

(-)resources/ChangeSignature/canModify/A_testAll46b_out.java (+14 lines)
1	package p;
2	class A{
3	A(int i){
4	}
5	void f(){
6	new A();
7	}
8	A(String a){
9	this();
10	}
11	A() {
12	this(1);
13	}
14	}

Added Link Here

(-)resources/ChangeSignature/canModify/A_testGenerics05_in.java (+5 lines)
1	package p;
2
3	class A<E> {
4	<T> void m(T t, E e) {}
5	}




package p;

import java.util.HashMap;
import java.util.List;

class A<E> {
	<T> void m(E e, T t, List<HashMap> maps) {}

	/**
	 * @deprecated use instead m(E e, T t, java.util.List<HashMap> maps)
	 */
	<T> void m(T t, E e) {
		m(e, t, null);
	}
}




package p;

import java.util.ArrayList;
import java.util.List;

class A<E> {
	public <T extends Number> void m(List<Integer> li, A<String> as) {}
}

class Sub<E> extends A<E> {
	public <T> void m(List<Integer> li, A<String> as) {}
	
	void test() {
		A<String> as= new A<String>();
		as.m(new ArrayList<Integer>(1), as);
		new Sub<Double>().m(new ArrayList<Integer>(2), as);
	}
}




package p;

import java.util.List;

class A<E> {
	public <T extends Number> void m(A<String> as, List<Integer> li) {}

	/**
	 * @deprecated use instead m(A<String> as, List<Integer> li)
	 */
	public <T extends Number> void m(List<Integer> li, A<String> as) {
		m(as, null);
	}
}

class Sub<E> extends A<E> {
	public <T> void m(A<String> as, List<Integer> li) {}
	
	void test() {
		A<String> as= new A<String>();
		as.m(as, null);
		new Sub<Double>().m(as, null);
	}

	/**
	 * @deprecated use instead m(A<String> as, List<Integer> li)
	 */
	public <T> void m(List<Integer> li, A<String> as) {
		m(as, null);
	}
}




package p;

class A {
	public void use(String... args) { System.out.println("hello world",args); }
	
	public void call() {
		use();
		use("one");
		use("one", "two");
		use(new String[] {"one", "two"});
		use(null);
		use((String[]) null);
		use((String) null);
	}
}




package p;

class A {
	public void use(int i, String... args) { System.out.println("hello world",args); }
	
	public void call() {
		use();
		use("one");
		use("one", "two");
		use(new String[] {"one", "two"});
		use(null);
		use((String[]) null);
		use((String) null);
	}

	public void use(String... args) {
		System.out.println("hello world", args);
	}
}

Return to bug 70135

Added Link Here

(-)resources/ChangeSignature/canModify/A_testGenerics05_out.java (+15 lines)
1	package p;
2
3	import java.util.HashMap;
4	import java.util.List;
5
6	class A<E> {
7	<T> void m(E e, T t, List<HashMap> maps) {}
8
9	/**
10	* @deprecated use instead m(E e, T t, java.util.List<HashMap> maps)
11	*/
12	<T> void m(T t, E e) {
13	m(e, t, null);
14	}
15	}

Added Link Here

(-)resources/ChangeSignature/canModify/A_testGenerics06_in.java (+18 lines)
1	package p;
2
3	import java.util.ArrayList;
4	import java.util.List;
5
6	class A<E> {
7	public <T extends Number> void m(List<Integer> li, A<String> as) {}
8	}
9
10	class Sub<E> extends A<E> {
11	public <T> void m(List<Integer> li, A<String> as) {}
12
13	void test() {
14	A<String> as= new A<String>();
15	as.m(new ArrayList<Integer>(1), as);
16	new Sub<Double>().m(new ArrayList<Integer>(2), as);
17	}
18	}