Add tests for 'if-when' and 'when' transformations

2013-04-26 14:36:31 +04:00
parent 06d43a8ab3
commit 7dd5a2cfa4
68 changed files with 799 additions and 2 deletions
@@ -313,7 +313,12 @@ public class GenerateTests {
                testModel("idea/testData/codeInsight/codeTransformations/branched/unfolding/assignmentToIf", "doTestUnfoldAssignmentToIf"),
                testModel("idea/testData/codeInsight/codeTransformations/branched/unfolding/assignmentToWhen", "doTestUnfoldAssignmentToWhen"),
                testModel("idea/testData/codeInsight/codeTransformations/branched/unfolding/returnToIf", "doTestUnfoldReturnToIf"),
-                testModel("idea/testData/codeInsight/codeTransformations/branched/unfolding/returnToWhen", "doTestUnfoldReturnToWhen")
+                testModel("idea/testData/codeInsight/codeTransformations/branched/unfolding/returnToWhen", "doTestUnfoldReturnToWhen"),
+                testModel("idea/testData/codeInsight/codeTransformations/branched/ifWhen/ifToWhen", "doTestIfToWhen"),
+                testModel("idea/testData/codeInsight/codeTransformations/branched/ifWhen/whenToIf", "doTestWhenToIf"),
+                testModel("idea/testData/codeInsight/codeTransformations/branched/when/flatten", "doTestFlattenWhen"),
+                testModel("idea/testData/codeInsight/codeTransformations/branched/when/introduceSubject", "doTestIntroduceWhenSubject"),
+                testModel("idea/testData/codeInsight/codeTransformations/branched/when/eliminateSubject", "doTestEliminateWhenSubject")
        );

        generateTest(
@@ -0,0 +1,9 @@
+fun test(n: Int): String {
+    return <caret>if (n == 0)
+        "zero"
+    else if (n == 1)
+        "one"
+    else if (n == 2)
+        "two"
+    else "unknown"
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when {
+        n == 0 -> "zero"
+        n == 1 -> "one"
+        n == 2 -> "two"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,9 @@
+fun test(obj: Any): String {
+    return <caret>if (obj is String)
+        "string"
+    else if (obj is Int)
+        "int"
+    else if (obj is Class<*>)
+        "class"
+    else "unknown"
+}
@@ -0,0 +1,8 @@
+fun test(obj: Any): String {
+    return <caret>when {
+        obj is String -> "string"
+        obj is Int -> "int"
+        obj is Class<*> -> "class"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,9 @@
+fun test(n: Int): String {
+    return <caret>if ((n < 0) || (n > 1000))
+        "unknown"
+    else if (n <= 10)
+        "small"
+    else if (n <= 100)
+        "average"
+    else "big"
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when {
+        n < 0, n > 1000 -> "unknown"
+        n <= 10 -> "small"
+        n <= 100 -> "average"
+        else -> "big"
+    }
+}
@@ -0,0 +1,9 @@
+fun test(obj: Any): String {
+    return <caret>if (obj !is Iterable<*>)
+        "not iterable"
+    else if (obj !is Collection<*>)
+        "not collection"
+    else if (obj !is MutableCollection<*>)
+        "not mutable collection"
+    else "unknown"
+}
@@ -0,0 +1,8 @@
+fun test(obj: Any): String {
+    return <caret>when {
+        obj !is Iterable<*> -> "not iterable"
+        obj !is Collection<*> -> "not collection"
+        obj !is MutableCollection<*> -> "not mutable collection"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,9 @@
+fun test(n: Int): String {
+    return <caret>if (n !in 0..1000)
+        "unknown"
+    else if (n !in 0..100)
+        "big"
+    else if (n !in 0..10)
+        "average"
+    else "small"
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when {
+        n !in 0..1000 -> "unknown"
+        n !in 0..100 -> "big"
+        n !in 0..10 -> "average"
+        else -> "small"
+    }
+}
@@ -0,0 +1,9 @@
+fun test(n: Int): String {
+    return <caret>if (n in 0..10)
+        "small"
+    else if (n in 10..100)
+        "average"
+    else if (n in 100..1000)
+        "big"
+    else "unknown"
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when {
+        n in 0..10 -> "small"
+        n in 10..100 -> "average"
+        n in 100..1000 -> "big"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,9 @@
+fun test(n: Int): String {
+    return <caret>if ((n in 0..5) || (n in 5..10))
+        "small"
+    else if ((n in 10..50) || (n in 50..100))
+        "average"
+    else if ((n in 100..500) || (n in 500..1000))
+        "big"
+    else "unknown"
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when {
+        n in 0..5, n in 5..10 -> "small"
+        n in 10..50, n in 50..100 -> "average"
+        n in 100..500, n in 500..1000 -> "big"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,9 @@
+fun test(n: Int): String {
+    return <caret>if ((n in 0..5) || (n in 5..10))
+        "small"
+    else if ((n in 10..50) || (n in 50..100))
+        "average"
+    else if ((n in 100..500) || (n in 500..1000))
+        "big"
+    else "unknown"
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when {
+        n in 0..5, n in 5..10 -> "small"
+        n in 10..50, n in 50..100 -> "average"
+        n in 100..500, n in 500..1000 -> "big"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when (n) {
+        0 -> "zero"
+        1 -> "one"
+        2 -> "two"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,9 @@
+fun test(n: Int): String {
+    return <caret>if (n == 0)
+        "zero"
+    else if (n == 1)
+        "one"
+    else if (n == 2)
+        "two"
+    else "unknown"
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when {
+        n < 0, n > 1000 -> "unknown"
+        n <= 10 -> "small"
+        n <= 100 -> "average"
+        else -> "big"
+    }
+}
@@ -0,0 +1,9 @@
+fun test(n: Int): String {
+    return <caret>if ((n < 0) || (n > 1000))
+        "unknown"
+    else if (n <= 10)
+        "small"
+    else if (n <= 100)
+        "average"
+    else "big"
+}
@@ -0,0 +1,8 @@
+fun test(obj: Any): String {
+    return <caret>when (obj) {
+        !is Iterable<*> -> "not iterable"
+        !is Collection<*> -> "not collection"
+        !is MutableCollection<*> -> "not mutable collection"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,9 @@
+fun test(obj: Any): String {
+    return <caret>if (obj !is Iterable<*>)
+        "not iterable"
+    else if (obj !is Collection<*>)
+        "not collection"
+    else if (obj !is MutableCollection<*>)
+        "not mutable collection"
+    else "unknown"
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when (n) {
+        !in 0..1000 -> "unknown"
+        !in 0..100 -> "big"
+        !in 0..10 -> "average"
+        else -> "small"
+    }
+}
@@ -0,0 +1,9 @@
+fun test(n: Int): String {
+    return <caret>if (n !in 0..1000)
+        "unknown"
+    else if (n !in 0..100)
+        "big"
+    else if (n !in 0..10)
+        "average"
+    else "small"
+}
@@ -0,0 +1,8 @@
+fun test(obj: Any): String {
+    return <caret>when (obj) {
+        is String -> "string"
+        is Int -> "int"
+        is Class<*> -> "class"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,9 @@
+fun test(obj: Any): String {
+    return <caret>if (obj is String)
+        "string"
+    else if (obj is Int)
+        "int"
+    else if (obj is Class<*>)
+        "class"
+    else "unknown"
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when (n) {
+        in 0..10 -> "small"
+        in 10..100 -> "average"
+        in 100..1000 -> "big"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,9 @@
+fun test(n: Int): String {
+    return <caret>if (n in 0..10)
+        "small"
+    else if (n in 10..100)
+        "average"
+    else if (n in 100..1000)
+        "big"
+    else "unknown"
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when (n) {
+        in 0..5, in 5..10 -> "small"
+        in 10..50, in 50..100 -> "average"
+        in 100..500, in 500..1000 -> "big"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,9 @@
+fun test(n: Int): String {
+    return <caret>if ((n in 0..5) || (n in 5..10))
+        "small"
+    else if ((n in 10..50) || (n in 50..100))
+        "average"
+    else if ((n in 100..500) || (n in 500..1000))
+        "big"
+    else "unknown"
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when {
+        n in 0..10 -> "small"
+        n in 10..100 -> "average"
+        n in 100..1000 -> "big"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,9 @@
+fun test(n: Int): String {
+    return <caret>if (n in 0..10)
+        "small"
+    else if (n in 10..100)
+        "average"
+    else if (n in 100..1000)
+        "big"
+    else "unknown"
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when (n) {
+        0 -> "zero"
+        1 -> "one"
+        2 -> "two"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when {
+        n == 0 -> "zero"
+        n == 1 -> "one"
+        n == 2 -> "two"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,8 @@
+fun test(obj: Any): String {
+    return <caret>when (obj) {
+        !is Iterable<*> -> "not iterable"
+        !is Collection<*> -> "not collection"
+        !is MutableCollection<*> -> "not mutable collection"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,8 @@
+fun test(obj: Any): String {
+    return <caret>when {
+        obj !is Iterable<*> -> "not iterable"
+        obj !is Collection<*> -> "not collection"
+        obj !is MutableCollection<*> -> "not mutable collection"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when (n) {
+        !in 0..1000 -> "unknown"
+        !in 0..100 -> "big"
+        !in 0..10 -> "average"
+        else -> "small"
+    }
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when {
+        n !in 0..1000 -> "unknown"
+        n !in 0..100 -> "big"
+        n !in 0..10 -> "average"
+        else -> "small"
+    }
+}
@@ -0,0 +1,8 @@
+fun test(obj: Any): String {
+    return <caret>when (obj) {
+        is String -> "string"
+        is Int -> "int"
+        is Class<*> -> "class"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,8 @@
+fun test(obj: Any): String {
+    return <caret>when {
+        obj is String -> "string"
+        obj is Int -> "int"
+        obj is Class<*> -> "class"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when (n) {
+        in 0..10 -> "small"
+        in 10..100 -> "average"
+        in 100..1000 -> "big"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when {
+        n in 0..10 -> "small"
+        n in 10..100 -> "average"
+        n in 100..1000 -> "big"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when (n) {
+        in 0..5, in 5..10 -> "small"
+        in 10..50, in 50..100 -> "average"
+        in 100..500, in 500..1000 -> "big"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when {
+        n in 0..5, n in 5..10 -> "small"
+        n in 10..50, n in 50..100 -> "average"
+        n in 100..500, n in 500..1000 -> "big"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,9 @@
+//IS_APPLICABLE: false
+fun test(n: Int): String {
+    return <caret>when {
+        n in 0..10 -> "small"
+        n in 10..100 -> "average"
+        n in 100..1000 -> "big"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,11 @@
+fun test(n: Int): String {
+    return <caret>when(n) {
+        in 0..10 -> "small"
+        in 10..100 -> "average"
+        else -> when(n) {
+            in 100..1000 -> "big"
+            in 1000..10000 -> "very big"
+            else -> "unknown"
+        }
+    }
+}
@@ -0,0 +1,9 @@
+fun test(n: Int): String {
+    return <caret>when (n) {
+        in 0..10 -> "small"
+        in 10..100 -> "average"
+        in 100..1000 -> "big"
+        in 1000..10000 -> "very big"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,12 @@
+//IS_APPLICABLE: false
+fun test(n: Int): String {
+    return <caret>when(n) {
+        in 0..10 -> "small"
+        in 10..100 -> "average"
+        else -> when {
+            n in 100..1000 -> "big"
+            n in 1000..10000 -> "very big"
+            else -> "unknown"
+        }
+    }
+}
@@ -0,0 +1,11 @@
+fun test(n: Int): String {
+    return <caret>when {
+        n in 0..10 -> "small"
+        n in 10..100 -> "average"
+        else -> when {
+            n in 100..1000 -> "big"
+            n in 1000..10000 -> "very big"
+            else -> "unknown"
+        }
+    }
+}
@@ -0,0 +1,9 @@
+fun test(n: Int): String {
+    return <caret>when {
+        n in 0..10 -> "small"
+        n in 10..100 -> "average"
+        n in 100..1000 -> "big"
+        n in 1000..10000 -> "very big"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when {
+        n == 0 -> "zero"
+        n == 1 -> "one"
+        n == 2 -> "two"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when (n) {
+        0 -> "zero"
+        1 -> "one"
+        2 -> "two"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,8 @@
+fun test(obj: Any): String {
+    return <caret>when {
+        obj !is Iterable<*> -> "not iterable"
+        obj !is Collection<*> -> "not collection"
+        obj !is MutableCollection<*> -> "not mutable collection"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,8 @@
+fun test(obj: Any): String {
+    return <caret>when (obj) {
+        !is Iterable<*> -> "not iterable"
+        !is Collection<*> -> "not collection"
+        !is MutableCollection<*> -> "not mutable collection"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when {
+        n !in 0..1000 -> "unknown"
+        n !in 0..100 -> "big"
+        n !in 0..10 -> "average"
+        else -> "small"
+    }
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when (n) {
+        !in 0..1000 -> "unknown"
+        !in 0..100 -> "big"
+        !in 0..10 -> "average"
+        else -> "small"
+    }
+}
@@ -0,0 +1,9 @@
+//IS_APPLICABLE: false
+fun test(n: Int): String {
+    return <caret>when {
+        n in 0..10 -> "small"
+        n >= 10 && n <= 100 -> "average"
+        n < 0, n > 1000 -> "unknown"
+        else -> "big"
+    }
+}
@@ -0,0 +1,8 @@
+fun test(obj: Any): String {
+    return <caret>when {
+        obj is String -> "string"
+        obj is Int -> "int"
+        obj is Class<*> -> "class"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,8 @@
+fun test(obj: Any): String {
+    return <caret>when (obj) {
+        is String -> "string"
+        is Int -> "int"
+        is Class<*> -> "class"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when {
+        n in 0..10 -> "small"
+        n in 10..100 -> "average"
+        n in 100..1000 -> "big"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when (n) {
+        in 0..10 -> "small"
+        in 10..100 -> "average"
+        in 100..1000 -> "big"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when {
+        n in 0..5, n in 5..10 -> "small"
+        n in 10..50, n in 50..100 -> "average"
+        n in 100..500, n in 500..1000 -> "big"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,8 @@
+fun test(n: Int): String {
+    return <caret>when (n) {
+        in 0..5, in 5..10 -> "small"
+        in 10..50, in 50..100 -> "average"
+        in 100..500, in 500..1000 -> "big"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,9 @@
+//IS_APPLICABLE: false
+fun test(n: Int): String {
+    return <caret>when(n) {
+        in 0..10 -> "small"
+        in 10..100 -> "average"
+        in 100..1000 -> "big"
+        else -> "unknown"
+    }
+}
@@ -0,0 +1,9 @@
+//IS_APPLICABLE: false
+fun test(n: Int): String {
+    return <caret>when {
+        n in 0..10 -> "n is small"
+        n/10 in 0..10 -> "m is average"
+        n/100 in 0..10 -> "n is big"
+        else -> "unknown"
+    }
+}
@@ -62,6 +62,26 @@ public abstract class AbstractCodeTransformationTest extends LightCodeInsightTes
        doTest(path, new UnfoldBranchedExpressionIntention.UnfoldReturnToWhenIntention());
    }

+    public void doTestIfToWhen(@NotNull String path) throws Exception {
+        doTest(path, new IfToWhenIntention());
+    }
+
+    public void doTestWhenToIf(@NotNull String path) throws Exception {
+        doTest(path, new WhenToIfIntention());
+    }
+
+    public void doTestFlattenWhen(@NotNull String path) throws Exception {
+        doTest(path, new FlattenWhenIntention());
+    }
+
+    public void doTestIntroduceWhenSubject(@NotNull String path) throws Exception {
+        doTest(path, new IntroduceWhenSubjectIntention());
+    }
+
+    public void doTestEliminateWhenSubject(@NotNull String path) throws Exception {
+        doTest(path, new EliminateWhenSubjectIntention());
+    }
+
    public void doTestRemoveUnnecessaryParentheses(@NotNull String path) throws Exception {
        doTest(path, new RemoveUnnecessaryParenthesesIntention());
    }
@@ -30,7 +30,7 @@ import org.jetbrains.jet.plugin.codeInsight.codeTransformations.AbstractCodeTran

 /** This class is generated by {@link org.jetbrains.jet.generators.tests.GenerateTests}. DO NOT MODIFY MANUALLY */
@SuppressWarnings("all")
-@InnerTestClasses({CodeTransformationsTestGenerated.IfToAssignment.class, CodeTransformationsTestGenerated.IfToReturn.class, CodeTransformationsTestGenerated.IfToReturnAsymmetrically.class, CodeTransformationsTestGenerated.WhenToAssignment.class, CodeTransformationsTestGenerated.WhenToReturn.class, CodeTransformationsTestGenerated.AssignmentToIf.class, CodeTransformationsTestGenerated.AssignmentToWhen.class, CodeTransformationsTestGenerated.ReturnToIf.class, CodeTransformationsTestGenerated.ReturnToWhen.class})
+@InnerTestClasses({CodeTransformationsTestGenerated.IfToAssignment.class, CodeTransformationsTestGenerated.IfToReturn.class, CodeTransformationsTestGenerated.IfToReturnAsymmetrically.class, CodeTransformationsTestGenerated.WhenToAssignment.class, CodeTransformationsTestGenerated.WhenToReturn.class, CodeTransformationsTestGenerated.AssignmentToIf.class, CodeTransformationsTestGenerated.AssignmentToWhen.class, CodeTransformationsTestGenerated.ReturnToIf.class, CodeTransformationsTestGenerated.ReturnToWhen.class, CodeTransformationsTestGenerated.IfToWhen.class, CodeTransformationsTestGenerated.WhenToIf.class, CodeTransformationsTestGenerated.Flatten.class, CodeTransformationsTestGenerated.IntroduceSubject.class, CodeTransformationsTestGenerated.EliminateSubject.class})
 public class CodeTransformationsTestGenerated extends AbstractCodeTransformationTest {
    @TestMetadata("idea/testData/codeInsight/codeTransformations/branched/folding/ifToAssignment")
    public static class IfToAssignment extends AbstractCodeTransformationTest {
@@ -299,6 +299,221 @@ public class CodeTransformationsTestGenerated extends AbstractCodeTransformation
        
    }
    
+    @TestMetadata("idea/testData/codeInsight/codeTransformations/branched/ifWhen/ifToWhen")
+    public static class IfToWhen extends AbstractCodeTransformationTest {
+        public void testAllFilesPresentInIfToWhen() throws Exception {
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/codeInsight/codeTransformations/branched/ifWhen/ifToWhen"), Pattern.compile("^(.+)\\.kt$"), true);
+        }
+        
+        @TestMetadata("ifWithEqualityTests.kt")
+        public void testIfWithEqualityTests() throws Exception {
+            doTestIfToWhen("idea/testData/codeInsight/codeTransformations/branched/ifWhen/ifToWhen/ifWithEqualityTests.kt");
+        }
+        
+        @TestMetadata("ifWithIs.kt")
+        public void testIfWithIs() throws Exception {
+            doTestIfToWhen("idea/testData/codeInsight/codeTransformations/branched/ifWhen/ifToWhen/ifWithIs.kt");
+        }
+        
+        @TestMetadata("ifWithMultiConditions.kt")
+        public void testIfWithMultiConditions() throws Exception {
+            doTestIfToWhen("idea/testData/codeInsight/codeTransformations/branched/ifWhen/ifToWhen/ifWithMultiConditions.kt");
+        }
+        
+        @TestMetadata("ifWithNegativeIs.kt")
+        public void testIfWithNegativeIs() throws Exception {
+            doTestIfToWhen("idea/testData/codeInsight/codeTransformations/branched/ifWhen/ifToWhen/ifWithNegativeIs.kt");
+        }
+        
+        @TestMetadata("ifWithNegativeRangeTests.kt")
+        public void testIfWithNegativeRangeTests() throws Exception {
+            doTestIfToWhen("idea/testData/codeInsight/codeTransformations/branched/ifWhen/ifToWhen/ifWithNegativeRangeTests.kt");
+        }
+        
+        @TestMetadata("ifWithRangeTests.kt")
+        public void testIfWithRangeTests() throws Exception {
+            doTestIfToWhen("idea/testData/codeInsight/codeTransformations/branched/ifWhen/ifToWhen/ifWithRangeTests.kt");
+        }
+        
+        @TestMetadata("ifWithRangeTestsAndMultiConditions.kt")
+        public void testIfWithRangeTestsAndMultiConditions() throws Exception {
+            doTestIfToWhen("idea/testData/codeInsight/codeTransformations/branched/ifWhen/ifToWhen/ifWithRangeTestsAndMultiConditions.kt");
+        }
+        
+        @TestMetadata("ifWithRangeTestsAndUnparenthesizedMultiConditions.kt")
+        public void testIfWithRangeTestsAndUnparenthesizedMultiConditions() throws Exception {
+            doTestIfToWhen("idea/testData/codeInsight/codeTransformations/branched/ifWhen/ifToWhen/ifWithRangeTestsAndUnparenthesizedMultiConditions.kt");
+        }
+        
+    }
+    
+    @TestMetadata("idea/testData/codeInsight/codeTransformations/branched/ifWhen/whenToIf")
+    public static class WhenToIf extends AbstractCodeTransformationTest {
+        public void testAllFilesPresentInWhenToIf() throws Exception {
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/codeInsight/codeTransformations/branched/ifWhen/whenToIf"), Pattern.compile("^(.+)\\.kt$"), true);
+        }
+        
+        @TestMetadata("whenWithEqualityTests.kt")
+        public void testWhenWithEqualityTests() throws Exception {
+            doTestWhenToIf("idea/testData/codeInsight/codeTransformations/branched/ifWhen/whenToIf/whenWithEqualityTests.kt");
+        }
+        
+        @TestMetadata("whenWithMultiConditions.kt")
+        public void testWhenWithMultiConditions() throws Exception {
+            doTestWhenToIf("idea/testData/codeInsight/codeTransformations/branched/ifWhen/whenToIf/whenWithMultiConditions.kt");
+        }
+        
+        @TestMetadata("whenWithNegativePatterns.kt")
+        public void testWhenWithNegativePatterns() throws Exception {
+            doTestWhenToIf("idea/testData/codeInsight/codeTransformations/branched/ifWhen/whenToIf/whenWithNegativePatterns.kt");
+        }
+        
+        @TestMetadata("whenWithNegativeRangeTests.kt")
+        public void testWhenWithNegativeRangeTests() throws Exception {
+            doTestWhenToIf("idea/testData/codeInsight/codeTransformations/branched/ifWhen/whenToIf/whenWithNegativeRangeTests.kt");
+        }
+        
+        @TestMetadata("whenWithPatterns.kt")
+        public void testWhenWithPatterns() throws Exception {
+            doTestWhenToIf("idea/testData/codeInsight/codeTransformations/branched/ifWhen/whenToIf/whenWithPatterns.kt");
+        }
+        
+        @TestMetadata("whenWithRangeTests.kt")
+        public void testWhenWithRangeTests() throws Exception {
+            doTestWhenToIf("idea/testData/codeInsight/codeTransformations/branched/ifWhen/whenToIf/whenWithRangeTests.kt");
+        }
+        
+        @TestMetadata("whenWithRangeTestsAndMultiConditions.kt")
+        public void testWhenWithRangeTestsAndMultiConditions() throws Exception {
+            doTestWhenToIf("idea/testData/codeInsight/codeTransformations/branched/ifWhen/whenToIf/whenWithRangeTestsAndMultiConditions.kt");
+        }
+        
+        @TestMetadata("whenWithoutSubject.kt")
+        public void testWhenWithoutSubject() throws Exception {
+            doTestWhenToIf("idea/testData/codeInsight/codeTransformations/branched/ifWhen/whenToIf/whenWithoutSubject.kt");
+        }
+        
+    }
+    
+    @TestMetadata("idea/testData/codeInsight/codeTransformations/branched/when/flatten")
+    public static class Flatten extends AbstractCodeTransformationTest {
+        public void testAllFilesPresentInFlatten() throws Exception {
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/codeInsight/codeTransformations/branched/when/flatten"), Pattern.compile("^(.+)\\.kt$"), true);
+        }
+        
+        @TestMetadata("flattenWithSubject.kt")
+        public void testFlattenWithSubject() throws Exception {
+            doTestFlattenWhen("idea/testData/codeInsight/codeTransformations/branched/when/flatten/flattenWithSubject.kt");
+        }
+        
+        @TestMetadata("flattenWithUnmatchedSubjects.kt")
+        public void testFlattenWithUnmatchedSubjects() throws Exception {
+            doTestFlattenWhen("idea/testData/codeInsight/codeTransformations/branched/when/flatten/flattenWithUnmatchedSubjects.kt");
+        }
+        
+        @TestMetadata("flattenWithoutSubject.kt")
+        public void testFlattenWithoutSubject() throws Exception {
+            doTestFlattenWhen("idea/testData/codeInsight/codeTransformations/branched/when/flatten/flattenWithoutSubject.kt");
+        }
+        
+    }
+    
+    @TestMetadata("idea/testData/codeInsight/codeTransformations/branched/when/introduceSubject")
+    public static class IntroduceSubject extends AbstractCodeTransformationTest {
+        public void testAllFilesPresentInIntroduceSubject() throws Exception {
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/codeInsight/codeTransformations/branched/when/introduceSubject"), Pattern.compile("^(.+)\\.kt$"), true);
+        }
+        
+        @TestMetadata("whenWithEqualityTests.kt")
+        public void testWhenWithEqualityTests() throws Exception {
+            doTestIntroduceWhenSubject("idea/testData/codeInsight/codeTransformations/branched/when/introduceSubject/whenWithEqualityTests.kt");
+        }
+        
+        @TestMetadata("whenWithNegativePatterns.kt")
+        public void testWhenWithNegativePatterns() throws Exception {
+            doTestIntroduceWhenSubject("idea/testData/codeInsight/codeTransformations/branched/when/introduceSubject/whenWithNegativePatterns.kt");
+        }
+        
+        @TestMetadata("whenWithNegativeRangeTests.kt")
+        public void testWhenWithNegativeRangeTests() throws Exception {
+            doTestIntroduceWhenSubject("idea/testData/codeInsight/codeTransformations/branched/when/introduceSubject/whenWithNegativeRangeTests.kt");
+        }
+        
+        @TestMetadata("whenWithNondivisibleConditions.kt")
+        public void testWhenWithNondivisibleConditions() throws Exception {
+            doTestIntroduceWhenSubject("idea/testData/codeInsight/codeTransformations/branched/when/introduceSubject/whenWithNondivisibleConditions.kt");
+        }
+        
+        @TestMetadata("whenWithPatterns.kt")
+        public void testWhenWithPatterns() throws Exception {
+            doTestIntroduceWhenSubject("idea/testData/codeInsight/codeTransformations/branched/when/introduceSubject/whenWithPatterns.kt");
+        }
+        
+        @TestMetadata("whenWithRangeTests.kt")
+        public void testWhenWithRangeTests() throws Exception {
+            doTestIntroduceWhenSubject("idea/testData/codeInsight/codeTransformations/branched/when/introduceSubject/whenWithRangeTests.kt");
+        }
+        
+        @TestMetadata("whenWithRangeTestsAndMultiConditions.kt")
+        public void testWhenWithRangeTestsAndMultiConditions() throws Exception {
+            doTestIntroduceWhenSubject("idea/testData/codeInsight/codeTransformations/branched/when/introduceSubject/whenWithRangeTestsAndMultiConditions.kt");
+        }
+        
+        @TestMetadata("whenWithSubject.kt")
+        public void testWhenWithSubject() throws Exception {
+            doTestIntroduceWhenSubject("idea/testData/codeInsight/codeTransformations/branched/when/introduceSubject/whenWithSubject.kt");
+        }
+        
+        @TestMetadata("whenWithUnmatchedCandidateSubjects.kt")
+        public void testWhenWithUnmatchedCandidateSubjects() throws Exception {
+            doTestIntroduceWhenSubject("idea/testData/codeInsight/codeTransformations/branched/when/introduceSubject/whenWithUnmatchedCandidateSubjects.kt");
+        }
+        
+    }
+    
+    @TestMetadata("idea/testData/codeInsight/codeTransformations/branched/when/eliminateSubject")
+    public static class EliminateSubject extends AbstractCodeTransformationTest {
+        public void testAllFilesPresentInEliminateSubject() throws Exception {
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.GenerateTests", new File("idea/testData/codeInsight/codeTransformations/branched/when/eliminateSubject"), Pattern.compile("^(.+)\\.kt$"), true);
+        }
+        
+        @TestMetadata("whenWithEqualityTests.kt")
+        public void testWhenWithEqualityTests() throws Exception {
+            doTestEliminateWhenSubject("idea/testData/codeInsight/codeTransformations/branched/when/eliminateSubject/whenWithEqualityTests.kt");
+        }
+        
+        @TestMetadata("whenWithNegativePatterns.kt")
+        public void testWhenWithNegativePatterns() throws Exception {
+            doTestEliminateWhenSubject("idea/testData/codeInsight/codeTransformations/branched/when/eliminateSubject/whenWithNegativePatterns.kt");
+        }
+        
+        @TestMetadata("whenWithNegativeRangeTests.kt")
+        public void testWhenWithNegativeRangeTests() throws Exception {
+            doTestEliminateWhenSubject("idea/testData/codeInsight/codeTransformations/branched/when/eliminateSubject/whenWithNegativeRangeTests.kt");
+        }
+        
+        @TestMetadata("whenWithPatterns.kt")
+        public void testWhenWithPatterns() throws Exception {
+            doTestEliminateWhenSubject("idea/testData/codeInsight/codeTransformations/branched/when/eliminateSubject/whenWithPatterns.kt");
+        }
+        
+        @TestMetadata("whenWithRangeTests.kt")
+        public void testWhenWithRangeTests() throws Exception {
+            doTestEliminateWhenSubject("idea/testData/codeInsight/codeTransformations/branched/when/eliminateSubject/whenWithRangeTests.kt");
+        }
+        
+        @TestMetadata("whenWithRangeTestsAndMultiConditions.kt")
+        public void testWhenWithRangeTestsAndMultiConditions() throws Exception {
+            doTestEliminateWhenSubject("idea/testData/codeInsight/codeTransformations/branched/when/eliminateSubject/whenWithRangeTestsAndMultiConditions.kt");
+        }
+        
+        @TestMetadata("whenWithoutSubject.kt")
+        public void testWhenWithoutSubject() throws Exception {
+            doTestEliminateWhenSubject("idea/testData/codeInsight/codeTransformations/branched/when/eliminateSubject/whenWithoutSubject.kt");
+        }
+        
+    }
+    
    public static Test suite() {
        TestSuite suite = new TestSuite("CodeTransformationsTestGenerated");
        suite.addTestSuite(IfToAssignment.class);
@@ -310,6 +525,11 @@ public class CodeTransformationsTestGenerated extends AbstractCodeTransformation
        suite.addTestSuite(AssignmentToWhen.class);
        suite.addTestSuite(ReturnToIf.class);
        suite.addTestSuite(ReturnToWhen.class);
+        suite.addTestSuite(IfToWhen.class);
+        suite.addTestSuite(WhenToIf.class);
+        suite.addTestSuite(Flatten.class);
+        suite.addTestSuite(IntroduceSubject.class);
+        suite.addTestSuite(EliminateSubject.class);
        return suite;
    }
 }