test++

java/java-tests/testData/refactoring/extractMethod/AnonInner.java

@@ -0,0 +1,21 @@
+
+import javax.swing.*;
+import java.awt.event.ActionEvent;
+
+public class ExtractMethods { }
+abstract class MyButton
+        extends JButton
+        {
+    protected MyButton( String text ) {
+        super( text );
+    }
+}
+class Foo {
+    private JButton createOKButton() {
+        return new MyButton( "OK" ) {
+            public void actionPerformed( ActionEvent e ) {
+            <selection>    setVisible( false ); </selection>
+            }
+        };
+    }
+}

java/java-tests/testData/refactoring/extractMethod/AnonInner_after.java

@@ -0,0 +1,25 @@
+
+import javax.swing.*;
+import java.awt.event.ActionEvent;
+
+public class ExtractMethods { }
+abstract class MyButton
+        extends JButton
+        {
+    protected MyButton( String text ) {
+        super( text );
+    }
+}
+class Foo {
+    private JButton createOKButton() {
+        return new MyButton( "OK" ) {
+            public void actionPerformed( ActionEvent e ) {
+                newMethod();
+            }
+        };
+    }
+
+    private void newMethod() {
+        setVisible( false );
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ArrayAccess.java

@@ -0,0 +1,8 @@
+class Test {
+  void foo(String[] ss) {
+     for(int i = 0; i < ss.length; i++) {
+       <selection>System.out.println(ss[i]);
+       System.out.println(ss[i] + ss[i]);</selection>
+     }
+  }
+}

java/java-tests/testData/refactoring/extractMethod/ArrayAccess1.java

@@ -0,0 +1,10 @@
+class Test {
+  void foo(String[] ss, String[] bb) {
+     for(int i = 0; i < ss.length; i++) {
+       <selection>
+       System.out.println(ss[i]);
+       System.out.println(bb[i]);
+       </selection>
+     }
+  }
+}

java/java-tests/testData/refactoring/extractMethod/ArrayAccess1_after.java

@@ -0,0 +1,14 @@
+class Test {
+  void foo(String[] ss, String[] bb) {
+     for(int i = 0; i < ss.length; i++) {
+
+         newMethod(ss[i], bb[i]);
+       
+     }
+  }
+
+    private void newMethod(String s, String x) {
+        System.out.println(s);
+        System.out.println(x);
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ArrayAccessWithDuplicates.java

@@ -0,0 +1,6 @@
+class Test {
+  void foo(String[] ss) {
+    <selection>System.out.println(ss[0]);</selection>
+    System.out.println(ss[0]);
+  }
+}

java/java-tests/testData/refactoring/extractMethod/ArrayAccessWithDuplicates_after.java

@@ -0,0 +1,10 @@
+class Test {
+  void foo(String[] ss) {
+      newMethod(ss[0]);
+      newMethod(ss[0]);
+  }
+
+    private void newMethod(String s) {
+        System.out.println(s);
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ArrayAccess_after.java

@@ -0,0 +1,12 @@
+class Test {
+  void foo(String[] ss) {
+     for(int i = 0; i < ss.length; i++) {
+         newMethod(ss[i]);
+     }
+  }
+
+    private void newMethod(String s) {
+        System.out.println(s);
+        System.out.println(s + s);
+    }
+}

java/java-tests/testData/refactoring/extractMethod/BooleanExpression.java

@@ -0,0 +1,5 @@
+class Test {
+    void method(int i) {
+        boolean isDirty = <selection>i == 0</selection> || otherTests();
+    }
+}

java/java-tests/testData/refactoring/extractMethod/BooleanExpression_after.java

@@ -0,0 +1,9 @@
+class Test {
+    void method(int i) {
+        boolean isDirty = newMethod(i) || otherTests();
+    }
+
+    private boolean newMethod(int i) {
+        return i == 0;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ChainedConstructor.java

@@ -0,0 +1,9 @@
+class A {
+    private int i;
+    private int j;
+
+    public A(int i, int j) {
+        <selection>this.i = i;</selection>
+        this.j = j;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ChainedConstructorDuplicates.java

@@ -0,0 +1,15 @@
+class A {
+    private int i;
+    private int j;
+    private int s;
+
+    public A(int i, int j) {
+        <selection>this.i = i;</selection>
+        this.j = j;
+    }
+
+    public A(int i, String s) {
+        this.i = i;
+        this.s = s;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ChainedConstructorDuplicates_after.java

@@ -0,0 +1,19 @@
+class A {
+    private int i;
+    private int j;
+    private int s;
+
+    public A(int i, int j) {
+        this(i);
+        this.j = j;
+    }
+
+    private A(int i) {
+        this.i = i;
+    }
+
+    public A(int i, String s) {
+        this(i);
+        this.s = s;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ChainedConstructorInvalidDuplicates.java

@@ -0,0 +1,15 @@
+class A {
+    private int i;
+    private int j;
+    private int s;
+
+    public A(int i, int j) {
+        <selection>this.i = i;</selection>
+        this.j = j;
+    }
+
+    public A(int i, String s) {
+        this.s = s;
+        this.i = i;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ChainedConstructorInvalidDuplicates_after.java

@@ -0,0 +1,19 @@
+class A {
+    private int i;
+    private int j;
+    private int s;
+
+    public A(int i, int j) {
+        this(i);
+        this.j = j;
+    }
+
+    private A(int i) {
+        this.i = i;
+    }
+
+    public A(int i, String s) {
+        this.s = s;
+        this.i = i;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ChainedConstructor_after.java

@@ -0,0 +1,13 @@
+class A {
+    private int i;
+    private int j;
+
+    public A(int i, int j) {
+        this(i);
+        this.j = j;
+    }
+
+    private A(int i) {
+        this.i = i;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicates.java

@@ -0,0 +1,8 @@
+class C {
+    {
+        int i;
+
+        <selection>System.out.println(i);</selection>
+        System.out.println(128);
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicates2.java

@@ -0,0 +1,15 @@
+class C {
+    {
+        Object[] array;
+
+        <selection>for (int i = 0; i < array.length; i++) {
+            System.out.println(array[i]);
+        }</selection>
+
+
+        Object[] array1;
+        for (int i = 0; i < array1.length; i++) {
+            System.out.println(array[i]);
+        }
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicates2_after.java

@@ -0,0 +1,19 @@
+class C {
+    {
+        Object[] array;
+
+        newMethod(array);
+
+
+        Object[] array1;
+        for (int i = 0; i < array1.length; i++) {
+            System.out.println(array[i]);
+        }
+    }
+
+    private void newMethod(Object[] array) {
+        for (int i = 0; i < array.length; i++) {
+            System.out.println(array[i]);
+        }
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicates3.java

@@ -0,0 +1,15 @@
+class C {
+    {
+        Object[] array;
+
+        <selection>for (int i = 0; i < array.length; i++) {
+            System.out.println(array[i]);
+        }</selection>
+
+
+        Object[] array1;
+        for (int i = 0; i < array1.length; i++) {
+            System.out.println(array1[i]);
+        }
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicates3_after.java

@@ -0,0 +1,17 @@
+class C {
+    {
+        Object[] array;
+
+        newMethod(array);
+
+
+        Object[] array1;
+        newMethod(array1);
+    }
+
+    private void newMethod(Object[] array) {
+        for (int i = 0; i < array.length; i++) {
+            System.out.println(array[i]);
+        }
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicates4.java

@@ -0,0 +1,15 @@
+class C {
+    {
+        Object[] array;
+
+        <selection>for (int i = 0; i < array.length; i++) {
+            System.out.println(array[i]);
+        }</selection>
+
+
+        Object[] array1;
+        for (int j = 0; j < array1.length; j++) {
+            System.out.println(array1[j]);
+        }
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicates4_after.java

@@ -0,0 +1,17 @@
+class C {
+    {
+        Object[] array;
+
+        newMethod(array);
+
+
+        Object[] array1;
+        newMethod(array1);
+    }
+
+    private void newMethod(Object[] array) {
+        for (int i = 0; i < array.length; i++) {
+            System.out.println(array[i]);
+        }
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicates5.java

@@ -0,0 +1,30 @@
+class D {}
+class C extends D {
+    int myField = 10;
+    int myOtherField = 10;
+
+    {
+        int i = 5;
+        <selection>myField = i;
+        myOtherField = i;</selection>
+
+        C c = new C();
+
+        c.myField = 12;
+        c.myOtherField = 12;
+
+        C c1 = new C();
+        c1.myField = 12;
+        myOtherField = 12;
+
+
+        //not a duplicate: method is not visible with qualifer class
+        D d1 = new D();
+        d1.myField = 12;
+        d1.myOtherField = 12;
+
+
+        c.myField = 15;
+        c1.myOtherField = 15;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicates5_after.java

@@ -0,0 +1,33 @@
+class D {}
+class C extends D {
+    int myField = 10;
+    int myOtherField = 10;
+
+    {
+        int i = 5;
+        newMethod(i);
+
+        C c = new C();
+
+        c.newMethod(12);
+
+        C c1 = new C();
+        c1.myField = 12;
+        myOtherField = 12;
+
+
+        //not a duplicate: method is not visible with qualifer class
+        D d1 = new D();
+        d1.myField = 12;
+        d1.myOtherField = 12;
+
+
+        c.myField = 15;
+        c1.myOtherField = 15;
+    }
+
+    private void newMethod(int i) {
+        myField = i;
+        myOtherField = i;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicatesWithComments.java

@@ -0,0 +1,19 @@
+class Test {
+    private List<Object> list1 = new ArrayList<Object>();
+
+    private List<Object> list2 = new ArrayList<Object>();
+
+    public void method1()
+    {
+        list1.add(null);
+        // add to list2
+        list2.add(true);
+    }
+
+    public void method2()
+    {
+        <selection>list1.add(null);
+        // add to list2
+        list2.add(true);</selection>
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicatesWithComments_after.java

@@ -0,0 +1,21 @@
+class Test {
+    private List<Object> list1 = new ArrayList<Object>();
+
+    private List<Object> list2 = new ArrayList<Object>();
+
+    public void method1()
+    {
+        newMethod();
+    }
+
+    public void method2()
+    {
+        newMethod();
+    }
+
+    private void newMethod() {
+        list1.add(null);
+        // add to list2
+        list2.add(true);
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicatesWithContinue.java

@@ -0,0 +1,14 @@
+class C {
+    void foo() {
+        for(int i = 0; i < 10; i++){
+        <selection>if (i < 10){ continue;}</selection>
+         System.out.println("");
+        }
+    }
+
+    {
+        for(int i = 0; i < 10; i++){
+          if (i < 10){ continue;}
+        }
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicatesWithContinueNoReturn.java

@@ -0,0 +1,13 @@
+class C {
+    void foo() {
+        for(int i = 0; i < 10; i++){
+        <selection>if (i < 10){ continue;}</selection>
+        }
+    }
+
+    {
+        for(int i = 0; i < 10; i++){
+          if (i < 10){ continue;}
+        }
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicatesWithContinueNoReturn_after.java

@@ -0,0 +1,19 @@
+class C {
+    void foo() {
+        for(int i = 0; i < 10; i++){
+            newMethod(i);
+        }
+    }
+
+    private void newMethod(int i) {
+        if (i < 10){
+            return;
+        }
+    }
+
+    {
+        for(int i = 0; i < 10; i++){
+            newMethod(i);
+        }
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicatesWithContinue_after.java

@@ -0,0 +1,21 @@
+class C {
+    void foo() {
+        for(int i = 0; i < 10; i++){
+            if (newMethod(i)) continue;
+            System.out.println("");
+        }
+    }
+
+    private boolean newMethod(int i) {
+        if (i < 10){
+            return true;
+        }
+        return false;
+    }
+
+    {
+        for(int i = 0; i < 10; i++){
+            if (newMethod(i)) continue;
+        }
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicatesWithMultExitPoints.java

@@ -0,0 +1,7 @@
+class A {
+   int foo (Object o) {
+     <selection>if (o == null) return 0;</selection>  
+     if (o == null) return 0;
+     return 1;
+   }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicatesWithMultExitPoints_after.java

@@ -0,0 +1,12 @@
+class A {
+   int foo (Object o) {
+       if (newMethod(o)) return 0;
+       if (newMethod(o)) return 0;
+       return 1;
+   }
+
+    private boolean newMethod(Object o) {
+        if (o == null) return true;
+        return false;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicatesWithOutputValue.java

@@ -0,0 +1,16 @@
+import java.util.*;
+
+class C {
+    {
+        Object[] array;
+
+        <selection>List l1 = new ArrayList(Arrays.asList(array));</selection>
+
+        List l2 = new ArrayList(Arrays.asList(getObjects()));
+
+        System.out.println("l1 = " + l1 + ", l2 = " + l2);
+    }
+
+    String[] getObjects() {
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicatesWithOutputValue1.java

@@ -0,0 +1,19 @@
+import java.util.*;
+
+class C {
+    {
+        Object[] array;
+
+        <selection>List l1 = null;
+        l1 = new ArrayList(Arrays.asList(array));</selection>
+
+        List l2 = null;
+        l2 = new ArrayList(Arrays.asList(getObjects()));
+
+        System.out.println("l1 = " + l1 + ", l2 = " + l2);
+    }
+
+
+    String[] getObjects() {
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicatesWithOutputValue1_after.java

@@ -0,0 +1,23 @@
+import java.util.*;
+
+class C {
+    {
+        Object[] array;
+
+        List l1 = newMethod(array);
+
+        List l2 = newMethod(getObjects());
+
+        System.out.println("l1 = " + l1 + ", l2 = " + l2);
+    }
+
+    private List newMethod(Object[] array) {
+        List l1 = null;
+        l1 = new ArrayList(Arrays.asList(array));
+        return l1;
+    }
+
+
+    String[] getObjects() {
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicatesWithOutputValue_after.java

@@ -0,0 +1,21 @@
+import java.util.*;
+
+class C {
+    {
+        Object[] array;
+
+        List l1 = newMethod(array);
+
+        List l2 = newMethod(getObjects());
+
+        System.out.println("l1 = " + l1 + ", l2 = " + l2);
+    }
+
+    private List newMethod(Object[] array) {
+        List l1 = new ArrayList(Arrays.asList(array));
+        return l1;
+    }
+
+    String[] getObjects() {
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicatesWithReturn.java

@@ -0,0 +1,13 @@
+class C {
+    String method(Object o) {
+        System.out.println(o);
+        <selection>Integer i = new Integer(o.hashCode());
+        return i.toString();</selection>
+    }
+
+    {
+        String k;
+        Integer j = new Integer(Boolean.TRUE.hashCode());
+        k = j.toString();
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicatesWithReturn2.java

@@ -0,0 +1,12 @@
+class C {
+    String method(Object o) {
+        System.out.println(o);
+        <selection>Integer i = new Integer(o.hashCode());
+        return i.toString();</selection>
+    }
+
+    {
+        Integer j = new Integer(Boolean.TRUE.hashCode());
+        String k = j.toString();
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicatesWithReturn2_after.java

@@ -0,0 +1,15 @@
+class C {
+    String method(Object o) {
+        System.out.println(o);
+        return newMethod(o);
+    }
+
+    private String newMethod(Object o) {
+        Integer i = new Integer(o.hashCode());
+        return i.toString();
+    }
+
+    {
+        String k = newMethod(Boolean.TRUE);
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicatesWithReturn_after.java

@@ -0,0 +1,16 @@
+class C {
+    String method(Object o) {
+        System.out.println(o);
+        return newMethod(o);
+    }
+
+    private String newMethod(Object o) {
+        Integer i = new Integer(o.hashCode());
+        return i.toString();
+    }
+
+    {
+        String k;
+        k = newMethod(Boolean.TRUE);
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicatesWithStaticInitializer.java

@@ -0,0 +1,11 @@
+class C {
+   static C c;
+   static {
+        java.util.ArrayList<C> l = null;
+        l.add(c);
+    }
+
+    void foo() {
+      System.out.println(<selection>c</selection>);
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicatesWithStaticInitializer_after.java

@@ -0,0 +1,15 @@
+class C {
+   static C c;
+   static {
+        java.util.ArrayList<C> l = null;
+        l.add(newMethod());
+    }
+
+    void foo() {
+      System.out.println(newMethod());
+    }
+
+    private static C newMethod() {
+        return c;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/CodeDuplicates_after.java

@@ -0,0 +1,12 @@
+class C {
+    {
+        int i;
+
+        newMethod(i);
+        newMethod(128);
+    }
+
+    private void newMethod(int i) {
+        System.out.println(i);
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ConstantConditionsAffectingControlFlow.java

@@ -0,0 +1,9 @@
+public /*abstract*/ class WillWorkTest {
+    int opera() {
+        int i = 0;
+        <selection>
+        int k;
+        if (true) k = i;
+        return k;</selection>
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ConstantConditionsAffectingControlFlow_after.java

@@ -0,0 +1,13 @@
+public /*abstract*/ class WillWorkTest {
+    int opera() {
+        int i = 0;
+
+        return newMethod(i);
+    }
+
+    private int newMethod(int i) {
+        int k;
+        if (true) k = i;
+        return k;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ExitPoints1.java

@@ -0,0 +1,9 @@
+class Test{
+  public void foo() {
+    if (cond1){
+      <selection>if (cond2) return;</selection>
+    }
+    else if (cond3){
+    }
+  }
+}

java/java-tests/testData/refactoring/extractMethod/ExitPoints2.java

@@ -0,0 +1,10 @@
+class Test{
+  public void foo() {
+    if (cond1){
+      <selection>if (cond2) return;</selection>
+    }
+    else if (cond3){
+    }
+    x();
+  }
+}

java/java-tests/testData/refactoring/extractMethod/ExitPoints2_after.java

@@ -0,0 +1,15 @@
+class Test{
+  public void foo() {
+    if (cond1){
+        if (newMethod()) return;
+    }
+    else if (cond3){
+    }
+    x();
+  }
+
+    private boolean newMethod() {
+        if (cond2) return true;
+        return false;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ExitPoints3.java

@@ -0,0 +1,10 @@
+class Test{
+  void foo() {
+    if (cond1){      
+      <selection>if (cond2) return;
+      x();</selection>
+    }
+    else if (cond3){
+    }
+  }
+}

java/java-tests/testData/refactoring/extractMethod/ExitPoints4.java

@@ -0,0 +1,12 @@
+class Test {
+    int method() {
+         <selection>try {
+             if(cond1) return 0;
+             else if(cond2) return 1;
+             System.out.println("Text");
+         } finally {           
+             doSomething();
+         }</selection>
+         return 12;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ExitPoints5.java

@@ -0,0 +1,12 @@
+class Test {
+    int method() {
+         <selection>try {
+             if(cond1) return 0;
+             else if(cond2) return 1;
+             return 27;
+         } finally {           
+             doSomething();
+         }</selection>
+         return 12;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ExitPoints5_after.java

@@ -0,0 +1,16 @@
+class Test {
+    int method() {
+        return newMethod();
+        return 12;
+    }
+
+    private int newMethod() {
+        try {
+            if(cond1) return 0;
+            else if(cond2) return 1;
+            return 27;
+        } finally {           
+            doSomething();
+        }
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ExitPoints6.java

@@ -0,0 +1,10 @@
+// multiple output values: one for modelling control flow + output value
+class K {
+    int f(Object o) {
+        <selection>if (o == null) return 0;
+        o = new Object();</selection>
+        Object oo = o;
+
+        return 1;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ExitPoints7.java

@@ -0,0 +1,27 @@
+class Foo {
+   public Object createBean(Object parent) {
+    try {
+      <selection>if (parent != null) {
+        try {
+        }
+        catch (Exception e) {
+          return null;
+        }
+      }
+
+
+      Object tag = null;</selection>
+
+      tag = foo(tag);
+    }
+    catch (Exception e) {
+      throw new RuntimeException(e);
+    }
+
+    return null;
+  }
+
+  private Object foo(final Object tag) {
+    return null;
+  }
+}

java/java-tests/testData/refactoring/extractMethod/ExitPoints8.java

@@ -0,0 +1,10 @@
+class C {
+    public Object m() {
+        <selection>for (Object o : new ArrayList<Object>()) {
+            if (o != null) {
+                return o;
+            }
+        }</selection>
+        return null;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ExitPoints9.java

@@ -0,0 +1,25 @@
+class Result {
+    private String _message;
+
+    public Result(String _message) {
+        this._message = _message;
+    }
+}
+
+class Main {
+    public static Result doIt(String name) {
+        Result result;
+
+        <selection>if (name == null) {
+            result = new Result("Name is null");
+            return result;
+        }
+        if (name.length() == 0) {
+            result = new Result("Name is empty");
+            return result;
+        }</selection>
+
+        result = new Result("Name is " + name);
+        return result;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ExitPointsInsideLoop.java

@@ -0,0 +1,9 @@
+class s {
+    void f(boolean b) {
+        for (;;) {
+            <selection>if (b) {
+                break;
+            }</selection>
+        }
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ExpressionDuplicates.java

@@ -0,0 +1,10 @@
+import java.util.*;
+
+class C {
+    {
+        Object[] o = null;
+        List l = <selection>new ArrayList(Arrays.asList(o))</selection>;
+
+        List l1 = new ArrayList(Arrays.asList(new Object[0]));
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ExpressionDuplicates_after.java

@@ -0,0 +1,14 @@
+import java.util.*;
+
+class C {
+    {
+        Object[] o = null;
+        List l = newMethod(o);
+
+        List l1 = newMethod(new Object[0]);
+    }
+
+    private ArrayList newMethod(Object[] o) {
+        return new ArrayList(Arrays.asList(o));
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ExtractFromAnonymous.java

@@ -0,0 +1,9 @@
+class Test {
+    public static void main() {
+        new Runnable() {
+            public void run() {
+                <selection>System.out</selection>.println("Text");
+            }
+        }
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ExtractFromAnonymous_after.java

@@ -0,0 +1,15 @@
+import java.io.PrintStream;
+
+class Test {
+    public static void main() {
+        new Runnable() {
+            public void run() {
+                newMethod().println("Text");
+            }
+        }
+    }
+
+    private static PrintStream newMethod() {
+        return System.out;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ExtractFromCodeBlock.java

@@ -0,0 +1,10 @@
+class Test {
+    void method() {
+        System.out.println("1");
+        <selection>{
+             System.out.println("2");
+             System.out.println("3");
+        }</selection>
+        System.out.println("4");
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ExtractFromCodeBlock_after.java

@@ -0,0 +1,12 @@
+class Test {
+    void method() {
+        System.out.println("1");
+        newMethod();
+        System.out.println("4");
+    }
+
+    private void newMethod() {
+        System.out.println("2");
+        System.out.println("3");
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ExtractFromFinally.java

@@ -0,0 +1,11 @@
+public class Test {
+    int method() {
+        try {
+            System.out.println("Text");
+            return 0;
+        } finally {
+            <selection>System.out.println("!!!");
+            return 1;</selection>
+        }
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ExtractFromFinally_after.java

@@ -0,0 +1,15 @@
+public class Test {
+    int method() {
+        try {
+            System.out.println("Text");
+            return 0;
+        } finally {
+            return newMethod();
+        }
+    }
+
+    private int newMethod() {
+        System.out.println("!!!");
+        return 1;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ExtractFromTryFinally.java

@@ -0,0 +1,10 @@
+public class S {
+  {
+    String s;
+    try {
+      <selection>s = "";</selection>
+    } finally {
+    }
+    System.out.print(s);
+  }
+}

java/java-tests/testData/refactoring/extractMethod/ExtractFromTryFinally2.java

@@ -0,0 +1,12 @@
+class Tester {
+    String x() {
+        String o = "";
+        <selection>String s;
+        try {
+            s = o;
+        }
+        finally {
+        }
+        return s;</selection>
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ExtractFromTryFinally2_after.java

@@ -0,0 +1,16 @@
+class Tester {
+    String x() {
+        String o = "";
+        return newMethod(o);
+    }
+
+    private String newMethod(String o) {
+        String s;
+        try {
+            s = o;
+        }
+        finally {
+        }
+        return s;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ExtractFromTryFinally_after.java

@@ -0,0 +1,16 @@
+public class S {
+  {
+    String s;
+    try {
+        s = newMethod();
+    } finally {
+    }
+    System.out.print(s);
+  }
+
+    private String newMethod() {
+        String s;
+        s = "";
+        return s;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/FinalOutputVar.java

@@ -0,0 +1,8 @@
+class C {
+    {
+        <selection>final int i = 128;</selection>
+        System.out.println("i = " + i);
+
+        final int j = 128;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/FinalOutputVar_after.java

@@ -0,0 +1,13 @@
+class C {
+    {
+        final int i = newMethod();
+        System.out.println("i = " + i);
+
+        final int j = newMethod();
+    }
+
+    private int newMethod() {
+        final int i = 128;
+        return i;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/FinalParamUsedInsideAnon.java

@@ -0,0 +1,11 @@
+public class Test {
+    public static void main(String[] args) {
+        final String s = "dude";
+        <selection>Runnable runnable = new Runnable() {
+            public void run() {
+                System.out.println(s);
+            }
+        };
+        new Thread(runnable).start();</selection>
+    }
+}

java/java-tests/testData/refactoring/extractMethod/FinalParamUsedInsideAnon_after.java

@@ -0,0 +1,15 @@
+public class Test {
+    public static void main(String[] args) {
+        final String s = "dude";
+        newMethod(s);
+    }
+
+    private static void newMethod(final String s) {
+        Runnable runnable = new Runnable() {
+            public void run() {
+                System.out.println(s);
+            }
+        };
+        new Thread(runnable).start();
+    }
+}

java/java-tests/testData/refactoring/extractMethod/Finally.java

@@ -0,0 +1,22 @@
+class Test {
+    void method(){         
+        <selection>try {
+            process.waitFor();
+        }
+        catch(InterruptedException e) {
+            process.destroy();
+        }
+        finally {
+            try {
+                myParsingThread.join();
+            }
+            catch(InterruptedException e) {
+            }
+            compilerHandler.processTerminated();
+        }
+        synchronized (this) {
+            myParsingThread = null;
+        }</selection>
+        someOtherCode();
+    }
+}

java/java-tests/testData/refactoring/extractMethod/Finally_after.java

@@ -0,0 +1,26 @@
+class Test {
+    void method(){
+        newMethod();
+        someOtherCode();
+    }
+
+    private void newMethod() {
+        try {
+            process.waitFor();
+        }
+        catch(InterruptedException e) {
+            process.destroy();
+        }
+        finally {
+            try {
+                myParsingThread.join();
+            }
+            catch(InterruptedException e) {
+            }
+            compilerHandler.processTerminated();
+        }
+        synchronized (this) {
+            myParsingThread = null;
+        }
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ForEach.java

@@ -0,0 +1,9 @@
+class Foo {
+  {
+    String[] args = getArgs();
+
+    for(String arg : args) {
+       <selection>System.out.println("arg = " + arg);</selection>
+    }
+  }
+}

java/java-tests/testData/refactoring/extractMethod/ForEach_after.java

@@ -0,0 +1,13 @@
+class Foo {
+  {
+    String[] args = getArgs();
+
+    for(String arg : args) {
+        newMethod(arg);
+    }
+  }
+
+    private void newMethod(String arg) {
+        System.out.println("arg = " + arg);
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ForceBraces.java

@@ -0,0 +1,9 @@
+class Xtract {
+    void me(int i) {
+        <selection>if (i ==10) {
+            return;
+        }</selection>
+
+        System.out.println("i: " + i);
+    }
+}

java/java-tests/testData/refactoring/extractMethod/ForceBraces_after.java

@@ -0,0 +1,16 @@
+class Xtract {
+    void me(int i) {
+        if (newMethod(i)) {
+            return;
+        }
+
+        System.out.println("i: " + i);
+    }
+
+    private boolean newMethod(int i) {
+        if (i ==10) {
+            return true;
+        }
+        return false;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/GenericsParameters.java

@@ -0,0 +1,5 @@
+class Test {
+   public final <T> Class<T> findClass(final String className) throws ClassNotFoundException {
+    return (Class<T>)Class.forName(className, true, <selection>getClass().getClassLoader()</selection>);
+  }
+}

java/java-tests/testData/refactoring/extractMethod/GenericsParameters_after.java

@@ -0,0 +1,9 @@
+class Test {
+   public final <T> Class<T> findClass(final String className) throws ClassNotFoundException {
+    return (Class<T>)Class.forName(className, true, newMethod());
+  }
+
+    private ClassLoader newMethod() {
+        return getClass().getClassLoader();
+    }
+}

java/java-tests/testData/refactoring/extractMethod/GuardMethodDuplicates.java

@@ -0,0 +1,18 @@
+class Test
+{
+    public Object foo() {
+        Object result = null;
+        <selection>if(test1()) return null;
+        if(test2()) return null;</selection>
+        return result;
+    }
+    public int foo1() {
+        int result = 1;
+        if(test1()) return 0;
+        if(test2()) return 0;
+        return result;
+    }
+
+    private boolean test1() {return false;}
+    private boolean test2() {return false;}
+}

java/java-tests/testData/refactoring/extractMethod/GuardMethodDuplicates1.java

@@ -0,0 +1,29 @@
+public class Test {
+    public Object foo() {
+        Object result = null;       // line1
+        <selection>if (test1()) return result;
+        if (test2()) return result;</selection>
+        if (test3()) return result;  // line4
+        return result;
+    }
+
+    public int foo1() {
+        Object result = null;       // line1
+        if (test1()) return 1; // ssss
+        if (test2()) return 1; //eee
+        if (test3()) return 2;  // line4
+        return 3;
+    }
+
+    private boolean test1() {
+        return false;
+    }
+
+    private boolean test2() {
+        return false;
+    }
+
+    private boolean test3() {
+        return false;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/GuardMethodDuplicates1_after.java

@@ -0,0 +1,34 @@
+public class Test {
+    public Object foo() {
+        Object result = null;       // line1
+        if (newMethod()) return result;
+        if (test3()) return result;  // line4
+        return result;
+    }
+
+    private boolean newMethod() {
+        Object result;
+        if (test1()) return true;
+        if (test2()) return true;
+        return false;
+    }
+
+    public int foo1() {
+        Object result = null;       // line1
+        if (newMethod()) return 1;
+        if (test3()) return 2;  // line4
+        return 3;
+    }
+
+    private boolean test1() {
+        return false;
+    }
+
+    private boolean test2() {
+        return false;
+    }
+
+    private boolean test3() {
+        return false;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/GuardMethodDuplicates_after.java

@@ -0,0 +1,23 @@
+class Test
+{
+    public Object foo() {
+        Object result = null;
+        if (newMethod()) return null;
+        return result;
+    }
+
+    private boolean newMethod() {
+        if(test1()) return true;
+        if(test2()) return true;
+        return false;
+    }
+
+    public int foo1() {
+        int result = 1;
+        if (newMethod()) return 0;
+        return result;
+    }
+
+    private boolean test1() {return false;}
+    private boolean test2() {return false;}
+}

java/java-tests/testData/refactoring/extractMethod/IDEADEV11036.java

@@ -0,0 +1,9 @@
+class MyClass {
+    public void newMethod(long i) {
+    }
+    {
+        int i = 0;
+        <selection>System.out.println(i);</selection>
+        newMethod(14);
+    }
+}

java/java-tests/testData/refactoring/extractMethod/IDEADEV11036_after.java

@@ -0,0 +1,13 @@
+class MyClass {
+    public void newMethod(long i) {
+    }
+    {
+        int i = 0;
+        newMethod(i);
+        newMethod((long) 14);
+    }
+
+    private void newMethod(int i) {
+        System.out.println(i);
+    }
+}

java/java-tests/testData/refactoring/extractMethod/IDEADEV11748.java

@@ -0,0 +1,14 @@
+class Test {
+    public static String bar(int x , int y) {
+        while (true) {
+            <selection>if (x == y) {
+                continue;
+            }
+            System.out.println("HW");</selection>
+        }
+    }
+
+    private static int g() {
+        return 0;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/IDEADEV11748_after.java

@@ -0,0 +1,18 @@
+class Test {
+    public static String bar(int x , int y) {
+        while (true) {
+            newMethod(x, y);
+        }
+    }
+
+    private static void newMethod(int x, int y) {
+        if (x == y) {
+            return;
+        }
+        System.out.println("HW");
+    }
+
+    private static int g() {
+        return 0;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/IDEADEV11848.java

@@ -0,0 +1,11 @@
+class Container {
+    static class X {
+        boolean x = false;
+
+        void foo(String s, String t) {
+            <selection>x = true;</selection>
+
+            x = true;
+        }
+    }
+}

java/java-tests/testData/refactoring/extractMethod/IDEADEV11848_after.java

@@ -0,0 +1,15 @@
+class Container {
+    static class X {
+        boolean x = false;
+
+        void foo(String s, String t) {
+            newMethod();
+
+            newMethod();
+        }
+
+        private void newMethod() {
+            x = true;
+        }
+    }
+}

java/java-tests/testData/refactoring/extractMethod/IDEADEV33368.java

@@ -0,0 +1,16 @@
+class Test {
+   void m(boolean b) {
+           int x = 42;
+           try {
+               <selection>
+               if(b) {
+                   x = 23;
+                   throw new Exception();
+               }
+               </selection>
+           } catch(Exception e) {
+               System.out.println(x);
+           }
+       }
+
+}

java/java-tests/testData/refactoring/extractMethod/IDEADEV33368_after.java

@@ -0,0 +1,21 @@
+class Test {
+   void m(boolean b) {
+           int x = 42;
+           try {
+
+               x = newMethod(b, x);
+
+           } catch(Exception e) {
+               System.out.println(x);
+           }
+       }
+
+    private int newMethod(boolean b, int x) throws Exception {
+        if(b) {
+            x = 23;
+            throw new Exception();
+        }
+        return x;
+    }
+
+}

java/java-tests/testData/refactoring/extractMethod/IdeaDev2291.java

@@ -0,0 +1,6 @@
+class Tester {
+    void method(Object... array) {
+        Object object = null;
+        <selection>array.equals(object);</selection> 
+    }
+}

java/java-tests/testData/refactoring/extractMethod/IdeaDev2291_after.java

@@ -0,0 +1,10 @@
+class Tester {
+    void method(Object... array) {
+        Object object = null;
+        newMethod(object, array);
+    }
+
+    private void newMethod(Object object, Object[] array) {
+        array.equals(object);
+    }
+}

java/java-tests/testData/refactoring/extractMethod/InstanceMethodDuplicatesInStaticContext.java

@@ -0,0 +1,14 @@
+class Class1 {
+    public static int staticMethod() {
+        int a = 1;
+        int b = 2;
+
+        int temp = a + b;
+        return temp * 2;
+    }
+
+    public int foo(int a, int b) {
+        <selection>int temp = a + b;
+        return temp * 2;</selection>
+    }
+}

java/java-tests/testData/refactoring/extractMethod/InstanceMethodDuplicatesInStaticContext_after.java

@@ -0,0 +1,17 @@
+class Class1 {
+    public static int staticMethod() {
+        int a = 1;
+        int b = 2;
+
+        return newMethod(a, b);
+    }
+
+    public int foo(int a, int b) {
+        return newMethod(a, b);
+    }
+
+    private static int newMethod(int a, int b) {
+        int temp = a + b;
+        return temp * 2;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/LValueNotDuplicate.java

@@ -0,0 +1,11 @@
+class UUU {
+    int myValue;
+
+    UUU() {
+        System.out.println(<selection>myValue</selection>);
+    }
+
+    void init() {
+        myValue = 0;
+    }
+}

java/java-tests/testData/refactoring/extractMethod/LValueNotDuplicate_after.java

@@ -0,0 +1,15 @@
+class UUU {
+    int myValue;
+
+    UUU() {
+        System.out.println(newMethod());
+    }
+
+    private int newMethod() {
+        return myValue;
+    }
+
+    void init() {
+        myValue = 0;
+    }
+}