Extract Function: Add test data

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/conditionalBreakWithIf.kt

@@ -0,0 +1,11 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        <selection>if (a + b > 0) break
+        println(a - b)
+        if (a - b > 0) break
+        println(a + b)</selection>
+    }
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/conditionalBreakWithIf.kt.after

@@ -0,0 +1,16 @@
+// NEXT_SIBLING:
+fun b(a: Int, b: Int): Boolean {
+    if (a + b > 0) return true
+    println(a - b)
+    if (a - b > 0) return true
+    println(a + b)
+    return false
+}
+
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        if (b(a, b)) break
+    }
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/conditionalBreakWithIfElse.kt

@@ -0,0 +1,13 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        <selection>if (a + b > 0) break
+        else {
+            println(a - b)
+            if (a - b > 0) break else println(a + b)
+        }
+        </selection>
+    }
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/conditionalBreakWithIfElse.kt.after

@@ -0,0 +1,18 @@
+// NEXT_SIBLING:
+fun b(a: Int, b: Int): Boolean {
+    if (a + b > 0) return true
+    else {
+        println(a - b)
+        if (a - b > 0) return true else println(a + b)
+    }
+    return false
+}
+
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        if (b(a, b)) break
+        
+    }
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/conditionalBreakWithWhen.kt

@@ -0,0 +1,12 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        <selection>when {
+            a + b > 0 -> break
+            a - b > 0 -> break
+            else -> println(0)
+        }</selection>
+    }
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/conditionalBreakWithWhen.kt.after

@@ -0,0 +1,17 @@
+// NEXT_SIBLING:
+fun b(a: Int, b: Int): Boolean {
+    when {
+        a + b > 0 -> return true
+        a - b > 0 -> return true
+        else -> println(0)
+    }
+    return false
+}
+
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        if (b(a, b)) break
+    }
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/conditionalReturnWithIf.kt

@@ -0,0 +1,7 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    <selection>if (a + b > 0) return 0
+    println(a - b)</selection>
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/conditionalReturnWithIf.kt.after

@@ -0,0 +1,12 @@
+// NEXT_SIBLING:
+fun b(a: Int, b: Int): Boolean {
+    if (a + b > 0) return true
+    println(a - b)
+    return false
+}
+
+fun foo(a: Int): Int {
+    val b: Int = 1
+    if (b(a, b)) return 0
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/conditionalReturnWithIfElse.kt

@@ -0,0 +1,8 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    <selection>if (a + b > 0) return 0
+    else if (a - b < 0) println(a - b)
+    else println(0)</selection>
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/conditionalReturnWithIfElse.kt.after

@@ -0,0 +1,13 @@
+// NEXT_SIBLING:
+fun b(a: Int, b: Int): Boolean {
+    if (a + b > 0) return true
+    else if (a - b < 0) println(a - b)
+    else println(0)
+    return false
+}
+
+fun foo(a: Int): Int {
+    val b: Int = 1
+    if (b(a, b)) return 0
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/conditionalReturnWithWhen.kt

@@ -0,0 +1,11 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    <selection>when (a + b) {
+        0 -> return 0
+        1 -> println(1)
+        else -> println(2)
+    }
+    </selection>
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/conditionalReturnWithWhen.kt.after

@@ -0,0 +1,16 @@
+// NEXT_SIBLING:
+fun b(a: Int, b: Int): Boolean {
+    when (a + b) {
+        0 -> return true
+        1 -> println(1)
+        else -> println(2)
+    }
+    return false
+}
+
+fun foo(a: Int): Int {
+    val b: Int = 1
+    if (b(a, b)) return 0
+    
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/unconditionalBreakWithIf.kt

@@ -0,0 +1,10 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        <selection>if (a + b > 0) break
+        println(a - b)
+        break</selection>
+    }
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/unconditionalBreakWithIf.kt.after

@@ -0,0 +1,15 @@
+// NEXT_SIBLING:
+fun unit(a: Int, b: Int) {
+    if (a + b > 0) return
+    println(a - b)
+    return
+}
+
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        unit(a, b)
+        break
+    }
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/unconditionalBreakWithIfElse.kt

@@ -0,0 +1,12 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        <selection>if (a + b > 0) break
+        else {
+            println(a - b)
+            break
+        }</selection>
+    }
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/unconditionalBreakWithIfElse.kt.after

@@ -0,0 +1,17 @@
+// NEXT_SIBLING:
+fun unit(a: Int, b: Int) {
+    if (a + b > 0) return
+    else {
+        println(a - b)
+        return
+    }
+}
+
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        unit(a, b)
+        break
+    }
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/unconditionalBreakWithWhen.kt

@@ -0,0 +1,15 @@
+// NEXT_SIBLING:
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        <selection>when {
+            a + b > 0 -> break
+            a - b > 0 -> break
+            else -> {
+                println(0)
+                break
+            }
+        }</selection>
+    }
+    return 1
+}

idea/testData/refactoring/extractFunction/controlFlow/conditionalJumps/unconditionalBreakWithWhen.kt.after

@@ -0,0 +1,20 @@
+// NEXT_SIBLING:
+fun unit(a: Int, b: Int) {
+    when {
+        a + b > 0 -> return
+        a - b > 0 -> return
+        else -> {
+            println(0)
+            return
+        }
+    }
+}
+
+fun foo(a: Int): Int {
+    val b: Int = 1
+    for (n in 1..a) {
+        unit(a, b)
+        break
+    }
+    return 1
+}