diff --git a/plugins/kotlin/formatter/src/org/jetbrains/kotlin/idea/formatter/KotlinCommonBlock.kt b/plugins/kotlin/formatter/src/org/jetbrains/kotlin/idea/formatter/KotlinCommonBlock.kt
index 438ba9c78c5b..d1e2d17d459b 100644
--- a/plugins/kotlin/formatter/src/org/jetbrains/kotlin/idea/formatter/KotlinCommonBlock.kt
+++ b/plugins/kotlin/formatter/src/org/jetbrains/kotlin/idea/formatter/KotlinCommonBlock.kt
@@ -906,7 +906,17 @@ private val INDENT_RULES = arrayOf(
     strategy("Indent for block content")
         .within(BLOCK, CLASS_BODY, FUNCTION_LITERAL)
         .notForType(RBRACE, LBRACE, BLOCK)
-        .set(Indent.getNormalIndent(false)),
+        .set(Indent.getNormalIndent()),
+
+    strategy("Indent for template content")
+        .within(LONG_STRING_TEMPLATE_ENTRY)
+        .notForType(LONG_TEMPLATE_ENTRY_START, LONG_TEMPLATE_ENTRY_END)
+        .set(Indent.getNormalIndent()),
+
+    strategy("No indent for braces in template")
+        .within(LONG_STRING_TEMPLATE_ENTRY)
+        .forType(LONG_TEMPLATE_ENTRY_START, LONG_TEMPLATE_ENTRY_END)
+        .set(Indent.getNoneIndent()),
 
     strategy("Indent for property accessors")
         .within(PROPERTY).forType(PROPERTY_ACCESSOR)
@@ -1006,7 +1016,7 @@ private val INDENT_RULES = arrayOf(
     strategy("Colon of delegation list")
         .within(CLASS, OBJECT_DECLARATION)
         .forType(COLON)
-        .set(Indent.getNormalIndent(false)),
+        .set(Indent.getNormalIndent()),
 
     strategy("Delegation list")
         .within(SUPER_TYPE_LIST)
diff --git a/plugins/kotlin/formatter/src/org/jetbrains/kotlin/idea/formatter/kotlinSpacingRules.kt b/plugins/kotlin/formatter/src/org/jetbrains/kotlin/idea/formatter/kotlinSpacingRules.kt
index a4372c34154c..755ceecc5492 100644
--- a/plugins/kotlin/formatter/src/org/jetbrains/kotlin/idea/formatter/kotlinSpacingRules.kt
+++ b/plugins/kotlin/formatter/src/org/jetbrains/kotlin/idea/formatter/kotlinSpacingRules.kt
@@ -240,6 +240,9 @@ fun createSpacingBuilder(settings: CodeStyleSettings, builderUtil: KotlinSpacing
                 else
                     null
             }
+
+            inPosition(parent = LONG_STRING_TEMPLATE_ENTRY, right = LONG_TEMPLATE_ENTRY_END).lineBreakIfLineBreakInParent(0)
+            inPosition(parent = LONG_STRING_TEMPLATE_ENTRY, left = LONG_TEMPLATE_ENTRY_START).lineBreakIfLineBreakInParent(0)
         }
 
         simple {
@@ -396,9 +399,6 @@ fun createSpacingBuilder(settings: CodeStyleSettings, builderUtil: KotlinSpacing
             betweenInside(LPAR, DESTRUCTURING_DECLARATION, FOR).spaces(0)
             betweenInside(LOOP_RANGE, RPAR, FOR).spaces(0)
 
-            after(LONG_TEMPLATE_ENTRY_START).spaces(0)
-            before(LONG_TEMPLATE_ENTRY_END).spaces(0)
-
             afterInside(ANNOTATION_ENTRY, ANNOTATED_EXPRESSION).spaces(1)
 
             before(SEMICOLON).spaces(0)
diff --git a/plugins/kotlin/idea/tests/test/org/jetbrains/kotlin/formatter/FormatterTestGenerated.java b/plugins/kotlin/idea/tests/test/org/jetbrains/kotlin/formatter/FormatterTestGenerated.java
index f82538cba969..3b1a059af4cb 100644
--- a/plugins/kotlin/idea/tests/test/org/jetbrains/kotlin/formatter/FormatterTestGenerated.java
+++ b/plugins/kotlin/idea/tests/test/org/jetbrains/kotlin/formatter/FormatterTestGenerated.java
@@ -18,7 +18,7 @@ import java.util.regex.Pattern;
 @SuppressWarnings("all")
 @RunWith(JUnit3RunnerWithInners.class)
 public class FormatterTestGenerated extends AbstractFormatterTest {
-    @TestMetadata("testData/formatter")
+    @TestMetadata("idea/testData/formatter")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class Formatter extends AbstractFormatterTest {
@@ -28,829 +28,859 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
 
         @TestMetadata("AfterSemiColonInEnumClass.after.kt")
         public void testAfterSemiColonInEnumClass() throws Exception {
-            runTest("testData/formatter/AfterSemiColonInEnumClass.after.kt");
+            runTest("idea/testData/formatter/AfterSemiColonInEnumClass.after.kt");
         }
 
         public void testAllFilesPresentInFormatter() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
         }
 
         @TestMetadata("AnnotationBeforeExpression.after.kt")
         public void testAnnotationBeforeExpression() throws Exception {
-            runTest("testData/formatter/AnnotationBeforeExpression.after.kt");
+            runTest("idea/testData/formatter/AnnotationBeforeExpression.after.kt");
         }
 
         @TestMetadata("AnnotationBeforeTypeAliasOrConstructor.after.kt")
         public void testAnnotationBeforeTypeAliasOrConstructor() throws Exception {
-            runTest("testData/formatter/AnnotationBeforeTypeAliasOrConstructor.after.kt");
+            runTest("idea/testData/formatter/AnnotationBeforeTypeAliasOrConstructor.after.kt");
         }
 
         @TestMetadata("AnonymousInitializers.after.kt")
         public void testAnonymousInitializers() throws Exception {
-            runTest("testData/formatter/AnonymousInitializers.after.kt");
+            runTest("idea/testData/formatter/AnonymousInitializers.after.kt");
         }
 
         @TestMetadata("AnonymousInitializersLineBreak.after.kt")
         public void testAnonymousInitializersLineBreak() throws Exception {
-            runTest("testData/formatter/AnonymousInitializersLineBreak.after.kt");
+            runTest("idea/testData/formatter/AnonymousInitializersLineBreak.after.kt");
         }
 
         @TestMetadata("ArrayAccess.after.kt")
         public void testArrayAccess() throws Exception {
-            runTest("testData/formatter/ArrayAccess.after.kt");
+            runTest("idea/testData/formatter/ArrayAccess.after.kt");
         }
 
         @TestMetadata("ArrayLiteral.after.kt")
         public void testArrayLiteral() throws Exception {
-            runTest("testData/formatter/ArrayLiteral.after.kt");
+            runTest("idea/testData/formatter/ArrayLiteral.after.kt");
         }
 
         @TestMetadata("AssignmentWrap.after.kt")
         public void testAssignmentWrap() throws Exception {
-            runTest("testData/formatter/AssignmentWrap.after.kt");
+            runTest("idea/testData/formatter/AssignmentWrap.after.kt");
         }
 
         @TestMetadata("BinaryExpressionAlignmentSpread.after.kt")
         public void testBinaryExpressionAlignmentSpread() throws Exception {
-            runTest("testData/formatter/BinaryExpressionAlignmentSpread.after.kt");
+            runTest("idea/testData/formatter/BinaryExpressionAlignmentSpread.after.kt");
         }
 
         @TestMetadata("BinaryExpressions.after.kt")
         public void testBinaryExpressions() throws Exception {
-            runTest("testData/formatter/BinaryExpressions.after.kt");
+            runTest("idea/testData/formatter/BinaryExpressions.after.kt");
         }
 
         @TestMetadata("BinaryExpressionsBoolean.after.kt")
         public void testBinaryExpressionsBoolean() throws Exception {
-            runTest("testData/formatter/BinaryExpressionsBoolean.after.kt");
+            runTest("idea/testData/formatter/BinaryExpressionsBoolean.after.kt");
         }
 
         @TestMetadata("BinaryExpressionsWithoutAlignment.after.kt")
         public void testBinaryExpressionsWithoutAlignment() throws Exception {
-            runTest("testData/formatter/BinaryExpressionsWithoutAlignment.after.kt");
+            runTest("idea/testData/formatter/BinaryExpressionsWithoutAlignment.after.kt");
         }
 
         @TestMetadata("BlankLinesAfterClassHeader.after.kt")
         public void testBlankLinesAfterClassHeader() throws Exception {
-            runTest("testData/formatter/BlankLinesAfterClassHeader.after.kt");
+            runTest("idea/testData/formatter/BlankLinesAfterClassHeader.after.kt");
         }
 
         @TestMetadata("BlankLinesBeforeRBrace.after.kt")
         public void testBlankLinesBeforeRBrace() throws Exception {
-            runTest("testData/formatter/BlankLinesBeforeRBrace.after.kt");
+            runTest("idea/testData/formatter/BlankLinesBeforeRBrace.after.kt");
         }
 
         @TestMetadata("BlankLinesBeforeRBrace2.after.kt")
         public void testBlankLinesBeforeRBrace2() throws Exception {
-            runTest("testData/formatter/BlankLinesBeforeRBrace2.after.kt");
+            runTest("idea/testData/formatter/BlankLinesBeforeRBrace2.after.kt");
         }
 
         @TestMetadata("BlockFor.after.kt")
         public void testBlockFor() throws Exception {
-            runTest("testData/formatter/BlockFor.after.kt");
+            runTest("idea/testData/formatter/BlockFor.after.kt");
         }
 
         @TestMetadata("By.after.kt")
         public void testBy() throws Exception {
-            runTest("testData/formatter/By.after.kt");
+            runTest("idea/testData/formatter/By.after.kt");
         }
 
         @TestMetadata("CallLParenthOnNextLine.after.kt")
         public void testCallLParenthOnNextLine() throws Exception {
-            runTest("testData/formatter/CallLParenthOnNextLine.after.kt");
+            runTest("idea/testData/formatter/CallLParenthOnNextLine.after.kt");
         }
 
         @TestMetadata("CallRParenthOnNextLine.after.kt")
         public void testCallRParenthOnNextLine() throws Exception {
-            runTest("testData/formatter/CallRParenthOnNextLine.after.kt");
+            runTest("idea/testData/formatter/CallRParenthOnNextLine.after.kt");
         }
 
         @TestMetadata("Cast.after.kt")
         public void testCast() throws Exception {
-            runTest("testData/formatter/Cast.after.kt");
+            runTest("idea/testData/formatter/Cast.after.kt");
         }
 
         @TestMetadata("CatchFinallyOnNewLine.after.kt")
         public void testCatchFinallyOnNewLine() throws Exception {
-            runTest("testData/formatter/CatchFinallyOnNewLine.after.kt");
+            runTest("idea/testData/formatter/CatchFinallyOnNewLine.after.kt");
         }
 
         @TestMetadata("Class.after.kt")
         public void testClass() throws Exception {
-            runTest("testData/formatter/Class.after.kt");
+            runTest("idea/testData/formatter/Class.after.kt");
         }
 
         @TestMetadata("ClassAnnotationWrapping.after.kt")
         public void testClassAnnotationWrapping() throws Exception {
-            runTest("testData/formatter/ClassAnnotationWrapping.after.kt");
+            runTest("idea/testData/formatter/ClassAnnotationWrapping.after.kt");
         }
 
         @TestMetadata("ClassInBody.after.kt")
         public void testClassInBody() throws Exception {
-            runTest("testData/formatter/ClassInBody.after.kt");
+            runTest("idea/testData/formatter/ClassInBody.after.kt");
         }
 
         @TestMetadata("ClassLineBreak.after.kt")
         public void testClassLineBreak() throws Exception {
-            runTest("testData/formatter/ClassLineBreak.after.kt");
+            runTest("idea/testData/formatter/ClassLineBreak.after.kt");
         }
 
         @TestMetadata("ClassTypeParam.after.kt")
         public void testClassTypeParam() throws Exception {
-            runTest("testData/formatter/ClassTypeParam.after.kt");
+            runTest("idea/testData/formatter/ClassTypeParam.after.kt");
         }
 
         @TestMetadata("ColonSpaces.after.kt")
         public void testColonSpaces() throws Exception {
-            runTest("testData/formatter/ColonSpaces.after.kt");
+            runTest("idea/testData/formatter/ColonSpaces.after.kt");
         }
 
         @TestMetadata("CommentAfterPackage.after.kt")
         public void testCommentAfterPackage() throws Exception {
-            runTest("testData/formatter/CommentAfterPackage.after.kt");
+            runTest("idea/testData/formatter/CommentAfterPackage.after.kt");
         }
 
         @TestMetadata("CommentInExpressionBodies.after.kt")
         public void testCommentInExpressionBodies() throws Exception {
-            runTest("testData/formatter/CommentInExpressionBodies.after.kt");
+            runTest("idea/testData/formatter/CommentInExpressionBodies.after.kt");
         }
 
         @TestMetadata("CommentInFunctionLiteral.after.kt")
         public void testCommentInFunctionLiteral() throws Exception {
-            runTest("testData/formatter/CommentInFunctionLiteral.after.kt");
+            runTest("idea/testData/formatter/CommentInFunctionLiteral.after.kt");
         }
 
         @TestMetadata("ContinuationIndentInAssigments.after.kt")
         public void testContinuationIndentInAssigments() throws Exception {
-            runTest("testData/formatter/ContinuationIndentInAssigments.after.kt");
+            runTest("idea/testData/formatter/ContinuationIndentInAssigments.after.kt");
         }
 
         @TestMetadata("ContinuationIndentInParameterLists.after.kt")
         public void testContinuationIndentInParameterLists() throws Exception {
-            runTest("testData/formatter/ContinuationIndentInParameterLists.after.kt");
+            runTest("idea/testData/formatter/ContinuationIndentInParameterLists.after.kt");
         }
 
         @TestMetadata("ContinuationIndentInSupertypeLists.after.kt")
         public void testContinuationIndentInSupertypeLists() throws Exception {
-            runTest("testData/formatter/ContinuationIndentInSupertypeLists.after.kt");
+            runTest("idea/testData/formatter/ContinuationIndentInSupertypeLists.after.kt");
         }
 
         @TestMetadata("CurlyBraceStringInterpolation.after.kt")
         public void testCurlyBraceStringInterpolation() throws Exception {
-            runTest("testData/formatter/CurlyBraceStringInterpolation.after.kt");
+            runTest("idea/testData/formatter/CurlyBraceStringInterpolation.after.kt");
         }
 
         @TestMetadata("DanglingComments.after.kt")
         public void testDanglingComments() throws Exception {
-            runTest("testData/formatter/DanglingComments.after.kt");
+            runTest("idea/testData/formatter/DanglingComments.after.kt");
         }
 
         @TestMetadata("DelegationList.after.kt")
         public void testDelegationList() throws Exception {
-            runTest("testData/formatter/DelegationList.after.kt");
+            runTest("idea/testData/formatter/DelegationList.after.kt");
         }
 
         @TestMetadata("DoWhileLineBreak.after.kt")
         public void testDoWhileLineBreak() throws Exception {
-            runTest("testData/formatter/DoWhileLineBreak.after.kt");
+            runTest("idea/testData/formatter/DoWhileLineBreak.after.kt");
         }
 
         @TestMetadata("DoWhileSpacing.after.kt")
         public void testDoWhileSpacing() throws Exception {
-            runTest("testData/formatter/DoWhileSpacing.after.kt");
+            runTest("idea/testData/formatter/DoWhileSpacing.after.kt");
         }
 
         @TestMetadata("DocComments.after.kt")
         public void testDocComments() throws Exception {
-            runTest("testData/formatter/DocComments.after.kt");
+            runTest("idea/testData/formatter/DocComments.after.kt");
         }
 
         @TestMetadata("ElseOnNewLine.after.kt")
         public void testElseOnNewLine() throws Exception {
-            runTest("testData/formatter/ElseOnNewLine.after.kt");
+            runTest("idea/testData/formatter/ElseOnNewLine.after.kt");
         }
 
         @TestMetadata("Elvis.after.kt")
         public void testElvis() throws Exception {
-            runTest("testData/formatter/Elvis.after.kt");
+            runTest("idea/testData/formatter/Elvis.after.kt");
         }
 
         @TestMetadata("ElvisContinuationIndentOptions.after.kt")
         public void testElvisContinuationIndentOptions() throws Exception {
-            runTest("testData/formatter/ElvisContinuationIndentOptions.after.kt");
+            runTest("idea/testData/formatter/ElvisContinuationIndentOptions.after.kt");
         }
 
         @TestMetadata("ElvisInStringTemplate.after.kt")
         public void testElvisInStringTemplate() throws Exception {
-            runTest("testData/formatter/ElvisInStringTemplate.after.kt");
+            runTest("idea/testData/formatter/ElvisInStringTemplate.after.kt");
         }
 
         @TestMetadata("ElvisIndent.after.kt")
         public void testElvisIndent() throws Exception {
-            runTest("testData/formatter/ElvisIndent.after.kt");
+            runTest("idea/testData/formatter/ElvisIndent.after.kt");
         }
 
         @TestMetadata("ElvisWithOperationReference.after.kt")
         public void testElvisWithOperationReference() throws Exception {
-            runTest("testData/formatter/ElvisWithOperationReference.after.kt");
+            runTest("idea/testData/formatter/ElvisWithOperationReference.after.kt");
         }
 
         @TestMetadata("ElvisWrap.after.kt")
         public void testElvisWrap() throws Exception {
-            runTest("testData/formatter/ElvisWrap.after.kt");
+            runTest("idea/testData/formatter/ElvisWrap.after.kt");
         }
 
         @TestMetadata("EmptyLineAfterObjectDeclaration.after.kt")
         public void testEmptyLineAfterObjectDeclaration() throws Exception {
-            runTest("testData/formatter/EmptyLineAfterObjectDeclaration.after.kt");
+            runTest("idea/testData/formatter/EmptyLineAfterObjectDeclaration.after.kt");
         }
 
         @TestMetadata("EmptyLineAfterPackage.after.kt")
         public void testEmptyLineAfterPackage() throws Exception {
-            runTest("testData/formatter/EmptyLineAfterPackage.after.kt");
+            runTest("idea/testData/formatter/EmptyLineAfterPackage.after.kt");
         }
 
         @TestMetadata("EmptyLineBetweeAbstractFunctions.after.kt")
         public void testEmptyLineBetweeAbstractFunctions() throws Exception {
-            runTest("testData/formatter/EmptyLineBetweeAbstractFunctions.after.kt");
+            runTest("idea/testData/formatter/EmptyLineBetweeAbstractFunctions.after.kt");
         }
 
         @TestMetadata("EmptyLineBetweeSecondaryConstructors.after.kt")
         public void testEmptyLineBetweeSecondaryConstructors() throws Exception {
-            runTest("testData/formatter/EmptyLineBetweeSecondaryConstructors.after.kt");
+            runTest("idea/testData/formatter/EmptyLineBetweeSecondaryConstructors.after.kt");
         }
 
         @TestMetadata("EmptyLineBetweenClassAndFunction.after.kt")
         public void testEmptyLineBetweenClassAndFunction() throws Exception {
-            runTest("testData/formatter/EmptyLineBetweenClassAndFunction.after.kt");
+            runTest("idea/testData/formatter/EmptyLineBetweenClassAndFunction.after.kt");
         }
 
         @TestMetadata("EmptyLineBetweenClasses.after.kt")
         public void testEmptyLineBetweenClasses() throws Exception {
-            runTest("testData/formatter/EmptyLineBetweenClasses.after.kt");
+            runTest("idea/testData/formatter/EmptyLineBetweenClasses.after.kt");
         }
 
         @TestMetadata("EmptyLineBetweenEnumEntries.after.kt")
         public void testEmptyLineBetweenEnumEntries() throws Exception {
-            runTest("testData/formatter/EmptyLineBetweenEnumEntries.after.kt");
+            runTest("idea/testData/formatter/EmptyLineBetweenEnumEntries.after.kt");
         }
 
         @TestMetadata("EmptyLineBetweenFunAndProperty.after.kt")
         public void testEmptyLineBetweenFunAndProperty() throws Exception {
-            runTest("testData/formatter/EmptyLineBetweenFunAndProperty.after.kt");
+            runTest("idea/testData/formatter/EmptyLineBetweenFunAndProperty.after.kt");
         }
 
         @TestMetadata("EmptyLineBetweenFunctions.after.kt")
         public void testEmptyLineBetweenFunctions() throws Exception {
-            runTest("testData/formatter/EmptyLineBetweenFunctions.after.kt");
+            runTest("idea/testData/formatter/EmptyLineBetweenFunctions.after.kt");
         }
 
         @TestMetadata("EmptyLineBetweenProperties.after.kt")
         public void testEmptyLineBetweenProperties() throws Exception {
-            runTest("testData/formatter/EmptyLineBetweenProperties.after.kt");
+            runTest("idea/testData/formatter/EmptyLineBetweenProperties.after.kt");
         }
 
         @TestMetadata("EnumArguments.after.kt")
         public void testEnumArguments() throws Exception {
-            runTest("testData/formatter/EnumArguments.after.kt");
+            runTest("idea/testData/formatter/EnumArguments.after.kt");
         }
 
         @TestMetadata("EnumEntiesWithComments.after.kt")
         public void testEnumEntiesWithComments() throws Exception {
-            runTest("testData/formatter/EnumEntiesWithComments.after.kt");
+            runTest("idea/testData/formatter/EnumEntiesWithComments.after.kt");
         }
 
         @TestMetadata("EnumInitializerList.after.kt")
         public void testEnumInitializerList() throws Exception {
-            runTest("testData/formatter/EnumInitializerList.after.kt");
+            runTest("idea/testData/formatter/EnumInitializerList.after.kt");
         }
 
         @TestMetadata("EnumWrapping.after.kt")
         public void testEnumWrapping() throws Exception {
-            runTest("testData/formatter/EnumWrapping.after.kt");
+            runTest("idea/testData/formatter/EnumWrapping.after.kt");
         }
 
         @TestMetadata("ExpressionBodyWrap.after.kt")
         public void testExpressionBodyWrap() throws Exception {
-            runTest("testData/formatter/ExpressionBodyWrap.after.kt");
+            runTest("idea/testData/formatter/ExpressionBodyWrap.after.kt");
         }
 
         @TestMetadata("ExtendsListAlignEnum.after.kt")
         public void testExtendsListAlignEnum() throws Exception {
-            runTest("testData/formatter/ExtendsListAlignEnum.after.kt");
+            runTest("idea/testData/formatter/ExtendsListAlignEnum.after.kt");
         }
 
         @TestMetadata("ExtendsListWrap.after.kt")
         public void testExtendsListWrap() throws Exception {
-            runTest("testData/formatter/ExtendsListWrap.after.kt");
+            runTest("idea/testData/formatter/ExtendsListWrap.after.kt");
         }
 
         @TestMetadata("ForLineBreak.after.kt")
         public void testForLineBreak() throws Exception {
-            runTest("testData/formatter/ForLineBreak.after.kt");
+            runTest("idea/testData/formatter/ForLineBreak.after.kt");
         }
 
         @TestMetadata("ForNoBraces.after.kt")
         public void testForNoBraces() throws Exception {
-            runTest("testData/formatter/ForNoBraces.after.kt");
+            runTest("idea/testData/formatter/ForNoBraces.after.kt");
         }
 
         @TestMetadata("ForSpacing.after.kt")
         public void testForSpacing() throws Exception {
-            runTest("testData/formatter/ForSpacing.after.kt");
+            runTest("idea/testData/formatter/ForSpacing.after.kt");
         }
 
         @TestMetadata("FormatFirstColumnComments.after.kt")
         public void testFormatFirstColumnComments() throws Exception {
-            runTest("testData/formatter/FormatFirstColumnComments.after.kt");
+            runTest("idea/testData/formatter/FormatFirstColumnComments.after.kt");
         }
 
         @TestMetadata("FormatFirstColumnCommentsBeforeDeclaration.after.kt")
         public void testFormatFirstColumnCommentsBeforeDeclaration() throws Exception {
-            runTest("testData/formatter/FormatFirstColumnCommentsBeforeDeclaration.after.kt");
+            runTest("idea/testData/formatter/FormatFirstColumnCommentsBeforeDeclaration.after.kt");
         }
 
         @TestMetadata("FunctionCallParametersAlign.after.kt")
         public void testFunctionCallParametersAlign() throws Exception {
-            runTest("testData/formatter/FunctionCallParametersAlign.after.kt");
+            runTest("idea/testData/formatter/FunctionCallParametersAlign.after.kt");
         }
 
         @TestMetadata("FunctionDefParametersAlign.after.kt")
         public void testFunctionDefParametersAlign() throws Exception {
-            runTest("testData/formatter/FunctionDefParametersAlign.after.kt");
+            runTest("idea/testData/formatter/FunctionDefParametersAlign.after.kt");
         }
 
         @TestMetadata("FunctionExpression.after.kt")
         public void testFunctionExpression() throws Exception {
-            runTest("testData/formatter/FunctionExpression.after.kt");
+            runTest("idea/testData/formatter/FunctionExpression.after.kt");
         }
 
         @TestMetadata("FunctionLineBreak.after.kt")
         public void testFunctionLineBreak() throws Exception {
-            runTest("testData/formatter/FunctionLineBreak.after.kt");
+            runTest("idea/testData/formatter/FunctionLineBreak.after.kt");
         }
 
         @TestMetadata("FunctionReferenceOperator.after.kt")
         public void testFunctionReferenceOperator() throws Exception {
-            runTest("testData/formatter/FunctionReferenceOperator.after.kt");
+            runTest("idea/testData/formatter/FunctionReferenceOperator.after.kt");
         }
 
         @TestMetadata("FunctionWithInference.after.kt")
         public void testFunctionWithInference() throws Exception {
-            runTest("testData/formatter/FunctionWithInference.after.kt");
+            runTest("idea/testData/formatter/FunctionWithInference.after.kt");
         }
 
         @TestMetadata("FunctionalType.after.kt")
         public void testFunctionalType() throws Exception {
-            runTest("testData/formatter/FunctionalType.after.kt");
+            runTest("idea/testData/formatter/FunctionalType.after.kt");
         }
 
         @TestMetadata("GetterAndSetter.after.kt")
         public void testGetterAndSetter() throws Exception {
-            runTest("testData/formatter/GetterAndSetter.after.kt");
+            runTest("idea/testData/formatter/GetterAndSetter.after.kt");
         }
 
         @TestMetadata("If.after.kt")
         public void testIf() throws Exception {
-            runTest("testData/formatter/If.after.kt");
+            runTest("idea/testData/formatter/If.after.kt");
         }
 
         @TestMetadata("IfClosingParen.after.kt")
         public void testIfClosingParen() throws Exception {
-            runTest("testData/formatter/IfClosingParen.after.kt");
+            runTest("idea/testData/formatter/IfClosingParen.after.kt");
         }
 
         @TestMetadata("IfConditionIndent.after.kt")
         public void testIfConditionIndent() throws Exception {
-            runTest("testData/formatter/IfConditionIndent.after.kt");
+            runTest("idea/testData/formatter/IfConditionIndent.after.kt");
         }
 
         @TestMetadata("IfElseRemoveLineBreak.after.kt")
         public void testIfElseRemoveLineBreak() throws Exception {
-            runTest("testData/formatter/IfElseRemoveLineBreak.after.kt");
+            runTest("idea/testData/formatter/IfElseRemoveLineBreak.after.kt");
         }
 
         @TestMetadata("IfElseWithLineBreak.after.kt")
         public void testIfElseWithLineBreak() throws Exception {
-            runTest("testData/formatter/IfElseWithLineBreak.after.kt");
+            runTest("idea/testData/formatter/IfElseWithLineBreak.after.kt");
         }
 
         @TestMetadata("IfElseWithTrickyComments.after.kt")
         public void testIfElseWithTrickyComments() throws Exception {
-            runTest("testData/formatter/IfElseWithTrickyComments.after.kt");
+            runTest("idea/testData/formatter/IfElseWithTrickyComments.after.kt");
         }
 
         @TestMetadata("IfRParen.after.kt")
         public void testIfRParen() throws Exception {
-            runTest("testData/formatter/IfRParen.after.kt");
+            runTest("idea/testData/formatter/IfRParen.after.kt");
         }
 
         @TestMetadata("IfSpacing.after.kt")
         public void testIfSpacing() throws Exception {
-            runTest("testData/formatter/IfSpacing.after.kt");
+            runTest("idea/testData/formatter/IfSpacing.after.kt");
         }
 
         @TestMetadata("In.after.kt")
         public void testIn() throws Exception {
-            runTest("testData/formatter/In.after.kt");
+            runTest("idea/testData/formatter/In.after.kt");
         }
 
         @TestMetadata("InfixCall.after.kt")
         public void testInfixCall() throws Exception {
-            runTest("testData/formatter/InfixCall.after.kt");
+            runTest("idea/testData/formatter/InfixCall.after.kt");
         }
 
         @TestMetadata("Is.after.kt")
         public void testIs() throws Exception {
-            runTest("testData/formatter/Is.after.kt");
+            runTest("idea/testData/formatter/Is.after.kt");
         }
 
         @TestMetadata("KDoc.after.kt")
         public void testKDoc() throws Exception {
-            runTest("testData/formatter/KDoc.after.kt");
+            runTest("idea/testData/formatter/KDoc.after.kt");
         }
 
         @TestMetadata("KT22230.after.kt")
         public void testKT22230() throws Exception {
-            runTest("testData/formatter/KT22230.after.kt");
+            runTest("idea/testData/formatter/KT22230.after.kt");
         }
 
         @TestMetadata("KeepLineBreak.after.kt")
         public void testKeepLineBreak() throws Exception {
-            runTest("testData/formatter/KeepLineBreak.after.kt");
+            runTest("idea/testData/formatter/KeepLineBreak.after.kt");
         }
 
         @TestMetadata("LabeledExpression.after.kt")
         public void testLabeledExpression() throws Exception {
-            runTest("testData/formatter/LabeledExpression.after.kt");
+            runTest("idea/testData/formatter/LabeledExpression.after.kt");
         }
 
         @TestMetadata("LambdaArrow.after.kt")
         public void testLambdaArrow() throws Exception {
-            runTest("testData/formatter/LambdaArrow.after.kt");
+            runTest("idea/testData/formatter/LambdaArrow.after.kt");
         }
 
         @TestMetadata("LineBreakBeforeExtendsColon.after.kt")
         public void testLineBreakBeforeExtendsColon() throws Exception {
-            runTest("testData/formatter/LineBreakBeforeExtendsColon.after.kt");
+            runTest("idea/testData/formatter/LineBreakBeforeExtendsColon.after.kt");
         }
 
         @TestMetadata("LineBreakBeforeExtendsColonWrap.after.kt")
         public void testLineBreakBeforeExtendsColonWrap() throws Exception {
-            runTest("testData/formatter/LineBreakBeforeExtendsColonWrap.after.kt");
+            runTest("idea/testData/formatter/LineBreakBeforeExtendsColonWrap.after.kt");
         }
 
         @TestMetadata("LocalVariableAnnotationWrap.after.kt")
         public void testLocalVariableAnnotationWrap() throws Exception {
-            runTest("testData/formatter/LocalVariableAnnotationWrap.after.kt");
+            runTest("idea/testData/formatter/LocalVariableAnnotationWrap.after.kt");
         }
 
         @TestMetadata("LoopParameterWithExplicitType.after.kt")
         public void testLoopParameterWithExplicitType() throws Exception {
-            runTest("testData/formatter/LoopParameterWithExplicitType.after.kt");
+            runTest("idea/testData/formatter/LoopParameterWithExplicitType.after.kt");
         }
 
         @TestMetadata("MethodAnnotationWrapping.after.kt")
         public void testMethodAnnotationWrapping() throws Exception {
-            runTest("testData/formatter/MethodAnnotationWrapping.after.kt");
+            runTest("idea/testData/formatter/MethodAnnotationWrapping.after.kt");
         }
 
         @TestMetadata("MethodCall.after.kt")
         public void testMethodCall() throws Exception {
-            runTest("testData/formatter/MethodCall.after.kt");
+            runTest("idea/testData/formatter/MethodCall.after.kt");
         }
 
         @TestMetadata("MethodLParenthOnNextLine.after.kt")
         public void testMethodLParenthOnNextLine() throws Exception {
-            runTest("testData/formatter/MethodLParenthOnNextLine.after.kt");
+            runTest("idea/testData/formatter/MethodLParenthOnNextLine.after.kt");
         }
 
         @TestMetadata("MethodRParenthOnNextLine.after.kt")
         public void testMethodRParenthOnNextLine() throws Exception {
-            runTest("testData/formatter/MethodRParenthOnNextLine.after.kt");
+            runTest("idea/testData/formatter/MethodRParenthOnNextLine.after.kt");
         }
 
         @TestMetadata("Multideclaration.after.kt")
         public void testMultideclaration() throws Exception {
-            runTest("testData/formatter/Multideclaration.after.kt");
+            runTest("idea/testData/formatter/Multideclaration.after.kt");
         }
 
         @TestMetadata("MultilineFunctionLiteral.after.kt")
         public void testMultilineFunctionLiteral() throws Exception {
-            runTest("testData/formatter/MultilineFunctionLiteral.after.kt");
+            runTest("idea/testData/formatter/MultilineFunctionLiteral.after.kt");
         }
 
         @TestMetadata("MultilineFunctionLiteralWithParams.after.kt")
         public void testMultilineFunctionLiteralWithParams() throws Exception {
-            runTest("testData/formatter/MultilineFunctionLiteralWithParams.after.kt");
+            runTest("idea/testData/formatter/MultilineFunctionLiteralWithParams.after.kt");
+        }
+
+        @TestMetadata("MultilineStringEntry.after.kt")
+        public void testMultilineStringEntry() throws Exception {
+            runTest("idea/testData/formatter/MultilineStringEntry.after.kt");
+        }
+
+        @TestMetadata("MultilineStringEntry2.after.kt")
+        public void testMultilineStringEntry2() throws Exception {
+            runTest("idea/testData/formatter/MultilineStringEntry2.after.kt");
+        }
+
+        @TestMetadata("MultilineStringEntry3.after.kt")
+        public void testMultilineStringEntry3() throws Exception {
+            runTest("idea/testData/formatter/MultilineStringEntry3.after.kt");
+        }
+
+        @TestMetadata("MultilineStringEntry4.after.kt")
+        public void testMultilineStringEntry4() throws Exception {
+            runTest("idea/testData/formatter/MultilineStringEntry4.after.kt");
+        }
+
+        @TestMetadata("MultilineStringEntry5.after.kt")
+        public void testMultilineStringEntry5() throws Exception {
+            runTest("idea/testData/formatter/MultilineStringEntry5.after.kt");
+        }
+
+        @TestMetadata("MultilineStringEntry6.after.kt")
+        public void testMultilineStringEntry6() throws Exception {
+            runTest("idea/testData/formatter/MultilineStringEntry6.after.kt");
         }
 
         @TestMetadata("NewLineForRBrace.after.kt")
         public void testNewLineForRBrace() throws Exception {
-            runTest("testData/formatter/NewLineForRBrace.after.kt");
+            runTest("idea/testData/formatter/NewLineForRBrace.after.kt");
         }
 
         @TestMetadata("NotIn.after.kt")
         public void testNotIn() throws Exception {
-            runTest("testData/formatter/NotIn.after.kt");
+            runTest("idea/testData/formatter/NotIn.after.kt");
         }
 
         @TestMetadata("NotIs.after.kt")
         public void testNotIs() throws Exception {
-            runTest("testData/formatter/NotIs.after.kt");
+            runTest("idea/testData/formatter/NotIs.after.kt");
         }
 
         @TestMetadata("NullableType.after.kt")
         public void testNullableType() throws Exception {
-            runTest("testData/formatter/NullableType.after.kt");
+            runTest("idea/testData/formatter/NullableType.after.kt");
         }
 
         @TestMetadata("ObjectInBody.after.kt")
         public void testObjectInBody() throws Exception {
-            runTest("testData/formatter/ObjectInBody.after.kt");
+            runTest("idea/testData/formatter/ObjectInBody.after.kt");
         }
 
         @TestMetadata("ParameterAnnotationWrap.after.kt")
         public void testParameterAnnotationWrap() throws Exception {
-            runTest("testData/formatter/ParameterAnnotationWrap.after.kt");
+            runTest("idea/testData/formatter/ParameterAnnotationWrap.after.kt");
         }
 
         @TestMetadata("ParameterDocComments.after.kt")
         public void testParameterDocComments() throws Exception {
-            runTest("testData/formatter/ParameterDocComments.after.kt");
+            runTest("idea/testData/formatter/ParameterDocComments.after.kt");
         }
 
         @TestMetadata("Parameters.after.kt")
         public void testParameters() throws Exception {
-            runTest("testData/formatter/Parameters.after.kt");
+            runTest("idea/testData/formatter/Parameters.after.kt");
         }
 
         @TestMetadata("PrimaryConstructor.after.kt")
         public void testPrimaryConstructor() throws Exception {
-            runTest("testData/formatter/PrimaryConstructor.after.kt");
+            runTest("idea/testData/formatter/PrimaryConstructor.after.kt");
         }
 
         @TestMetadata("PropertyAccessorLineBreak.after.kt")
         public void testPropertyAccessorLineBreak() throws Exception {
-            runTest("testData/formatter/PropertyAccessorLineBreak.after.kt");
+            runTest("idea/testData/formatter/PropertyAccessorLineBreak.after.kt");
         }
 
         @TestMetadata("PropertyAccessors.after.kt")
         public void testPropertyAccessors() throws Exception {
-            runTest("testData/formatter/PropertyAccessors.after.kt");
+            runTest("idea/testData/formatter/PropertyAccessors.after.kt");
         }
 
         @TestMetadata("PropertyAnnotationWrap.after.kt")
         public void testPropertyAnnotationWrap() throws Exception {
-            runTest("testData/formatter/PropertyAnnotationWrap.after.kt");
+            runTest("idea/testData/formatter/PropertyAnnotationWrap.after.kt");
         }
 
         @TestMetadata("PropertyInitializerLineBreak.after.kt")
         public void testPropertyInitializerLineBreak() throws Exception {
-            runTest("testData/formatter/PropertyInitializerLineBreak.after.kt");
+            runTest("idea/testData/formatter/PropertyInitializerLineBreak.after.kt");
         }
 
         @TestMetadata("PropertyTypeParameterList.after.kt")
         public void testPropertyTypeParameterList() throws Exception {
-            runTest("testData/formatter/PropertyTypeParameterList.after.kt");
+            runTest("idea/testData/formatter/PropertyTypeParameterList.after.kt");
         }
 
         @TestMetadata("PropertyWithInference.after.kt")
         public void testPropertyWithInference() throws Exception {
-            runTest("testData/formatter/PropertyWithInference.after.kt");
+            runTest("idea/testData/formatter/PropertyWithInference.after.kt");
         }
 
         @TestMetadata("ReferenceExpressionFunctionLiteral.after.kt")
         public void testReferenceExpressionFunctionLiteral() throws Exception {
-            runTest("testData/formatter/ReferenceExpressionFunctionLiteral.after.kt");
+            runTest("idea/testData/formatter/ReferenceExpressionFunctionLiteral.after.kt");
         }
 
         @TestMetadata("RemoveSpacesAroundOperations.after.kt")
         public void testRemoveSpacesAroundOperations() throws Exception {
-            runTest("testData/formatter/RemoveSpacesAroundOperations.after.kt");
+            runTest("idea/testData/formatter/RemoveSpacesAroundOperations.after.kt");
         }
 
         @TestMetadata("ReturnExpression.after.kt")
         public void testReturnExpression() throws Exception {
-            runTest("testData/formatter/ReturnExpression.after.kt");
+            runTest("idea/testData/formatter/ReturnExpression.after.kt");
         }
 
         @TestMetadata("RightBracketOnNewLine.after.kt")
         public void testRightBracketOnNewLine() throws Exception {
-            runTest("testData/formatter/RightBracketOnNewLine.after.kt");
+            runTest("idea/testData/formatter/RightBracketOnNewLine.after.kt");
         }
 
         @TestMetadata("SafeCast.after.kt")
         public void testSafeCast() throws Exception {
-            runTest("testData/formatter/SafeCast.after.kt");
+            runTest("idea/testData/formatter/SafeCast.after.kt");
         }
 
         @TestMetadata("SaveSpacesInDocComments.after.kt")
         public void testSaveSpacesInDocComments() throws Exception {
-            runTest("testData/formatter/SaveSpacesInDocComments.after.kt");
+            runTest("idea/testData/formatter/SaveSpacesInDocComments.after.kt");
         }
 
         @TestMetadata("Script.after.kts")
         public void testScript() throws Exception {
-            runTest("testData/formatter/Script.after.kts");
+            runTest("idea/testData/formatter/Script.after.kts");
         }
 
         @TestMetadata("SecondaryConstructors.after.kt")
         public void testSecondaryConstructors() throws Exception {
-            runTest("testData/formatter/SecondaryConstructors.after.kt");
+            runTest("idea/testData/formatter/SecondaryConstructors.after.kt");
         }
 
         @TestMetadata("secondaryCtorLineBreak.after.kt")
         public void testSecondaryCtorLineBreak() throws Exception {
-            runTest("testData/formatter/secondaryCtorLineBreak.after.kt");
+            runTest("idea/testData/formatter/secondaryCtorLineBreak.after.kt");
         }
 
         @TestMetadata("Semicolon.after.kt")
         public void testSemicolon() throws Exception {
-            runTest("testData/formatter/Semicolon.after.kt");
+            runTest("idea/testData/formatter/Semicolon.after.kt");
         }
 
         @TestMetadata("SingleLineFunctionLiteral.after.kt")
         public void testSingleLineFunctionLiteral() throws Exception {
-            runTest("testData/formatter/SingleLineFunctionLiteral.after.kt");
+            runTest("idea/testData/formatter/SingleLineFunctionLiteral.after.kt");
         }
 
         @TestMetadata("SpaceAroundDotInUserReference.after.kt")
         public void testSpaceAroundDotInUserReference() throws Exception {
-            runTest("testData/formatter/SpaceAroundDotInUserReference.after.kt");
+            runTest("idea/testData/formatter/SpaceAroundDotInUserReference.after.kt");
         }
 
         @TestMetadata("SpaceAroundExtendColon.after.kt")
         public void testSpaceAroundExtendColon() throws Exception {
-            runTest("testData/formatter/SpaceAroundExtendColon.after.kt");
+            runTest("idea/testData/formatter/SpaceAroundExtendColon.after.kt");
         }
 
         @TestMetadata("SpaceAroundExtendColonInObjects.after.kt")
         public void testSpaceAroundExtendColonInObjects() throws Exception {
-            runTest("testData/formatter/SpaceAroundExtendColonInObjects.after.kt");
+            runTest("idea/testData/formatter/SpaceAroundExtendColonInObjects.after.kt");
         }
 
         @TestMetadata("SpaceAroundExtendColonInSecondaryCtr.after.kt")
         public void testSpaceAroundExtendColonInSecondaryCtr() throws Exception {
-            runTest("testData/formatter/SpaceAroundExtendColonInSecondaryCtr.after.kt");
+            runTest("idea/testData/formatter/SpaceAroundExtendColonInSecondaryCtr.after.kt");
         }
 
         @TestMetadata("SpaceBeforeCatchParentheses.after.kt")
         public void testSpaceBeforeCatchParentheses() throws Exception {
-            runTest("testData/formatter/SpaceBeforeCatchParentheses.after.kt");
+            runTest("idea/testData/formatter/SpaceBeforeCatchParentheses.after.kt");
         }
 
         @TestMetadata("SpaceBeforeForParentheses.after.kt")
         public void testSpaceBeforeForParentheses() throws Exception {
-            runTest("testData/formatter/SpaceBeforeForParentheses.after.kt");
+            runTest("idea/testData/formatter/SpaceBeforeForParentheses.after.kt");
         }
 
         @TestMetadata("SpaceBeforeFunctionLiteral.after.kt")
         public void testSpaceBeforeFunctionLiteral() throws Exception {
-            runTest("testData/formatter/SpaceBeforeFunctionLiteral.after.kt");
+            runTest("idea/testData/formatter/SpaceBeforeFunctionLiteral.after.kt");
         }
 
         @TestMetadata("SpaceBeforeIfParentheses.after.kt")
         public void testSpaceBeforeIfParentheses() throws Exception {
-            runTest("testData/formatter/SpaceBeforeIfParentheses.after.kt");
+            runTest("idea/testData/formatter/SpaceBeforeIfParentheses.after.kt");
         }
 
         @TestMetadata("SpaceBeforeIndices.after.kt")
         public void testSpaceBeforeIndices() throws Exception {
-            runTest("testData/formatter/SpaceBeforeIndices.after.kt");
+            runTest("idea/testData/formatter/SpaceBeforeIndices.after.kt");
         }
 
         @TestMetadata("SpaceBeforeTypeArgumentList.after.kt")
         public void testSpaceBeforeTypeArgumentList() throws Exception {
-            runTest("testData/formatter/SpaceBeforeTypeArgumentList.after.kt");
+            runTest("idea/testData/formatter/SpaceBeforeTypeArgumentList.after.kt");
         }
 
         @TestMetadata("SpaceBeforeWhenParentheses.after.kt")
         public void testSpaceBeforeWhenParentheses() throws Exception {
-            runTest("testData/formatter/SpaceBeforeWhenParentheses.after.kt");
+            runTest("idea/testData/formatter/SpaceBeforeWhenParentheses.after.kt");
         }
 
         @TestMetadata("SpaceBeforeWhileParentheses.after.kt")
         public void testSpaceBeforeWhileParentheses() throws Exception {
-            runTest("testData/formatter/SpaceBeforeWhileParentheses.after.kt");
+            runTest("idea/testData/formatter/SpaceBeforeWhileParentheses.after.kt");
         }
 
         @TestMetadata("SpacedInsideParans.after.kt")
         public void testSpacedInsideParans() throws Exception {
-            runTest("testData/formatter/SpacedInsideParans.after.kt");
+            runTest("idea/testData/formatter/SpacedInsideParans.after.kt");
         }
 
         @TestMetadata("SpacesAroundOperations.after.kt")
         public void testSpacesAroundOperations() throws Exception {
-            runTest("testData/formatter/SpacesAroundOperations.after.kt");
+            runTest("idea/testData/formatter/SpacesAroundOperations.after.kt");
         }
 
         @TestMetadata("SpacesAroundUnaryOperations.after.kt")
         public void testSpacesAroundUnaryOperations() throws Exception {
-            runTest("testData/formatter/SpacesAroundUnaryOperations.after.kt");
+            runTest("idea/testData/formatter/SpacesAroundUnaryOperations.after.kt");
         }
 
         @TestMetadata("SpacesInDeclarations.after.kt")
         public void testSpacesInDeclarations() throws Exception {
-            runTest("testData/formatter/SpacesInDeclarations.after.kt");
+            runTest("idea/testData/formatter/SpacesInDeclarations.after.kt");
         }
 
         @TestMetadata("SpacesInQualifiedExpressions.after.kt")
         public void testSpacesInQualifiedExpressions() throws Exception {
-            runTest("testData/formatter/SpacesInQualifiedExpressions.after.kt");
+            runTest("idea/testData/formatter/SpacesInQualifiedExpressions.after.kt");
         }
 
         @TestMetadata("SuperListIndent.after.kt")
         public void testSuperListIndent() throws Exception {
-            runTest("testData/formatter/SuperListIndent.after.kt");
+            runTest("idea/testData/formatter/SuperListIndent.after.kt");
         }
 
         @TestMetadata("TryCatchLineBreak.after.kt")
         public void testTryCatchLineBreak() throws Exception {
-            runTest("testData/formatter/TryCatchLineBreak.after.kt");
+            runTest("idea/testData/formatter/TryCatchLineBreak.after.kt");
         }
 
         @TestMetadata("TypeAliasSpacing.after.kt")
         public void testTypeAliasSpacing() throws Exception {
-            runTest("testData/formatter/TypeAliasSpacing.after.kt");
+            runTest("idea/testData/formatter/TypeAliasSpacing.after.kt");
         }
 
         @TestMetadata("UnnecessarySpacesInParametersLists.after.kt")
         public void testUnnecessarySpacesInParametersLists() throws Exception {
-            runTest("testData/formatter/UnnecessarySpacesInParametersLists.after.kt");
+            runTest("idea/testData/formatter/UnnecessarySpacesInParametersLists.after.kt");
         }
 
         @TestMetadata("ValVarSpaces.after.kt")
         public void testValVarSpaces() throws Exception {
-            runTest("testData/formatter/ValVarSpaces.after.kt");
+            runTest("idea/testData/formatter/ValVarSpaces.after.kt");
         }
 
         @TestMetadata("When.after.kt")
         public void testWhen() throws Exception {
-            runTest("testData/formatter/When.after.kt");
+            runTest("idea/testData/formatter/When.after.kt");
         }
 
         @TestMetadata("WhenArrow.after.kt")
         public void testWhenArrow() throws Exception {
-            runTest("testData/formatter/WhenArrow.after.kt");
+            runTest("idea/testData/formatter/WhenArrow.after.kt");
         }
 
         @TestMetadata("WhenBlockBlankLines.after.kt")
         public void testWhenBlockBlankLines() throws Exception {
-            runTest("testData/formatter/WhenBlockBlankLines.after.kt");
+            runTest("idea/testData/formatter/WhenBlockBlankLines.after.kt");
         }
 
         @TestMetadata("WhenBraceAndEntry.after.kt")
         public void testWhenBraceAndEntry() throws Exception {
-            runTest("testData/formatter/WhenBraceAndEntry.after.kt");
+            runTest("idea/testData/formatter/WhenBraceAndEntry.after.kt");
         }
 
         @TestMetadata("WhenComment.after.kt")
         public void testWhenComment() throws Exception {
-            runTest("testData/formatter/WhenComment.after.kt");
+            runTest("idea/testData/formatter/WhenComment.after.kt");
         }
 
         @TestMetadata("WhenEntryExpr.after.kt")
         public void testWhenEntryExpr() throws Exception {
-            runTest("testData/formatter/WhenEntryExpr.after.kt");
+            runTest("idea/testData/formatter/WhenEntryExpr.after.kt");
         }
 
         @TestMetadata("WhenLineBreak.after.kt")
         public void testWhenLineBreak() throws Exception {
-            runTest("testData/formatter/WhenLineBreak.after.kt");
+            runTest("idea/testData/formatter/WhenLineBreak.after.kt");
         }
 
         @TestMetadata("WhenLinesBeforeLbrace.after.kt")
         public void testWhenLinesBeforeLbrace() throws Exception {
-            runTest("testData/formatter/WhenLinesBeforeLbrace.after.kt");
+            runTest("idea/testData/formatter/WhenLinesBeforeLbrace.after.kt");
         }
 
         @TestMetadata("WhenWithVariable.after.kt")
         public void testWhenWithVariable() throws Exception {
-            runTest("testData/formatter/WhenWithVariable.after.kt");
+            runTest("idea/testData/formatter/WhenWithVariable.after.kt");
         }
 
         @TestMetadata("WhereClause.after.kt")
         public void testWhereClause() throws Exception {
-            runTest("testData/formatter/WhereClause.after.kt");
+            runTest("idea/testData/formatter/WhereClause.after.kt");
         }
 
         @TestMetadata("WhileLineBreak.after.kt")
         public void testWhileLineBreak() throws Exception {
-            runTest("testData/formatter/WhileLineBreak.after.kt");
+            runTest("idea/testData/formatter/WhileLineBreak.after.kt");
         }
 
         @TestMetadata("WhileOnNewLine.after.kt")
         public void testWhileOnNewLine() throws Exception {
-            runTest("testData/formatter/WhileOnNewLine.after.kt");
+            runTest("idea/testData/formatter/WhileOnNewLine.after.kt");
         }
 
         @TestMetadata("WhileSpacing.after.kt")
         public void testWhileSpacing() throws Exception {
-            runTest("testData/formatter/WhileSpacing.after.kt");
+            runTest("idea/testData/formatter/WhileSpacing.after.kt");
         }
 
-        @TestMetadata("testData/formatter/callChain")
+        @TestMetadata("idea/testData/formatter/callChain")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class CallChain extends AbstractFormatterTest {
@@ -859,96 +889,96 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInCallChain() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/callChain"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/callChain"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
             }
 
             @TestMetadata("CallChainWrapping.after.kt")
             public void testCallChainWrapping() throws Exception {
-                runTest("testData/formatter/callChain/CallChainWrapping.after.kt");
+                runTest("idea/testData/formatter/callChain/CallChainWrapping.after.kt");
             }
 
             @TestMetadata("CallChainWrapping2.after.kt")
             public void testCallChainWrapping2() throws Exception {
-                runTest("testData/formatter/callChain/CallChainWrapping2.after.kt");
+                runTest("idea/testData/formatter/callChain/CallChainWrapping2.after.kt");
             }
 
             @TestMetadata("CallChainWrappingChopDown.after.kt")
             public void testCallChainWrappingChopDown() throws Exception {
-                runTest("testData/formatter/callChain/CallChainWrappingChopDown.after.kt");
+                runTest("idea/testData/formatter/callChain/CallChainWrappingChopDown.after.kt");
             }
 
             @TestMetadata("CallChainWrappingInElvis.after.kt")
             public void testCallChainWrappingInElvis() throws Exception {
-                runTest("testData/formatter/callChain/CallChainWrappingInElvis.after.kt");
+                runTest("idea/testData/formatter/callChain/CallChainWrappingInElvis.after.kt");
             }
 
             @TestMetadata("ConsecutiveCalls.after.kt")
             public void testConsecutiveCalls() throws Exception {
-                runTest("testData/formatter/callChain/ConsecutiveCalls.after.kt");
+                runTest("idea/testData/formatter/callChain/ConsecutiveCalls.after.kt");
             }
 
             @TestMetadata("ConsecutiveSafeCallsIndent.after.kt")
             public void testConsecutiveSafeCallsIndent() throws Exception {
-                runTest("testData/formatter/callChain/ConsecutiveSafeCallsIndent.after.kt");
+                runTest("idea/testData/formatter/callChain/ConsecutiveSafeCallsIndent.after.kt");
             }
 
             @TestMetadata("ContinuationIndentForChainedCalls.after.kt")
             public void testContinuationIndentForChainedCalls() throws Exception {
-                runTest("testData/formatter/callChain/ContinuationIndentForChainedCalls.after.kt");
+                runTest("idea/testData/formatter/callChain/ContinuationIndentForChainedCalls.after.kt");
             }
 
             @TestMetadata("FunctionLiteralsInChainCalls.after.kt")
             public void testFunctionLiteralsInChainCalls() throws Exception {
-                runTest("testData/formatter/callChain/FunctionLiteralsInChainCalls.after.kt");
+                runTest("idea/testData/formatter/callChain/FunctionLiteralsInChainCalls.after.kt");
             }
 
             @TestMetadata("KT15099.after.kt")
             public void testKT15099() throws Exception {
-                runTest("testData/formatter/callChain/KT15099.after.kt");
+                runTest("idea/testData/formatter/callChain/KT15099.after.kt");
             }
 
             @TestMetadata("KT20362.after.kt")
             public void testKT20362() throws Exception {
-                runTest("testData/formatter/callChain/KT20362.after.kt");
+                runTest("idea/testData/formatter/callChain/KT20362.after.kt");
             }
 
             @TestMetadata("KT22071.after.kt")
             public void testKT22071() throws Exception {
-                runTest("testData/formatter/callChain/KT22071.after.kt");
+                runTest("idea/testData/formatter/callChain/KT22071.after.kt");
             }
 
             @TestMetadata("KT22115.after.kt")
             public void testKT22115() throws Exception {
-                runTest("testData/formatter/callChain/KT22115.after.kt");
+                runTest("idea/testData/formatter/callChain/KT22115.after.kt");
             }
 
             @TestMetadata("KT22148.after.kt")
             public void testKT22148() throws Exception {
-                runTest("testData/formatter/callChain/KT22148.after.kt");
+                runTest("idea/testData/formatter/callChain/KT22148.after.kt");
             }
 
             @TestMetadata("KT22346.after.kt")
             public void testKT22346() throws Exception {
-                runTest("testData/formatter/callChain/KT22346.after.kt");
+                runTest("idea/testData/formatter/callChain/KT22346.after.kt");
             }
 
             @TestMetadata("KT36466.after.kt")
             public void testKT36466() throws Exception {
-                runTest("testData/formatter/callChain/KT36466.after.kt");
+                runTest("idea/testData/formatter/callChain/KT36466.after.kt");
             }
 
             @TestMetadata("KT37545.after.kt")
             public void testKT37545() throws Exception {
-                runTest("testData/formatter/callChain/KT37545.after.kt");
+                runTest("idea/testData/formatter/callChain/KT37545.after.kt");
             }
 
             @TestMetadata("NotCallChain.after.kt")
             public void testNotCallChain() throws Exception {
-                runTest("testData/formatter/callChain/NotCallChain.after.kt");
+                runTest("idea/testData/formatter/callChain/NotCallChain.after.kt");
             }
         }
 
-        @TestMetadata("testData/formatter/fileAnnotations")
+        @TestMetadata("idea/testData/formatter/fileAnnotations")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class FileAnnotations extends AbstractFormatterTest {
@@ -958,55 +988,55 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
 
             @TestMetadata("afterComment.after.kt")
             public void testAfterComment() throws Exception {
-                runTest("testData/formatter/fileAnnotations/afterComment.after.kt");
+                runTest("idea/testData/formatter/fileAnnotations/afterComment.after.kt");
             }
 
             public void testAllFilesPresentInFileAnnotations() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/fileAnnotations"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/fileAnnotations"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
             }
 
             @TestMetadata("beforeDeclaration.after.kt")
             public void testBeforeDeclaration() throws Exception {
-                runTest("testData/formatter/fileAnnotations/beforeDeclaration.after.kt");
+                runTest("idea/testData/formatter/fileAnnotations/beforeDeclaration.after.kt");
             }
 
             @TestMetadata("beforeImportList.after.kt")
             public void testBeforeImportList() throws Exception {
-                runTest("testData/formatter/fileAnnotations/beforeImportList.after.kt");
+                runTest("idea/testData/formatter/fileAnnotations/beforeImportList.after.kt");
             }
 
             @TestMetadata("beforePackage.after.kt")
             public void testBeforePackage() throws Exception {
-                runTest("testData/formatter/fileAnnotations/beforePackage.after.kt");
+                runTest("idea/testData/formatter/fileAnnotations/beforePackage.after.kt");
             }
 
             @TestMetadata("commentAfter.after.kt")
             public void testCommentAfter() throws Exception {
-                runTest("testData/formatter/fileAnnotations/commentAfter.after.kt");
+                runTest("idea/testData/formatter/fileAnnotations/commentAfter.after.kt");
             }
 
             @TestMetadata("commentAfter2.after.kt")
             public void testCommentAfter2() throws Exception {
-                runTest("testData/formatter/fileAnnotations/commentAfter2.after.kt");
+                runTest("idea/testData/formatter/fileAnnotations/commentAfter2.after.kt");
             }
 
             @TestMetadata("commentAfter3.after.kt")
             public void testCommentAfter3() throws Exception {
-                runTest("testData/formatter/fileAnnotations/commentAfter3.after.kt");
+                runTest("idea/testData/formatter/fileAnnotations/commentAfter3.after.kt");
             }
 
             @TestMetadata("inEmptyFile.after.kt")
             public void testInEmptyFile() throws Exception {
-                runTest("testData/formatter/fileAnnotations/inEmptyFile.after.kt");
+                runTest("idea/testData/formatter/fileAnnotations/inEmptyFile.after.kt");
             }
 
             @TestMetadata("manyLinesFromFileBegin.after.kt")
             public void testManyLinesFromFileBegin() throws Exception {
-                runTest("testData/formatter/fileAnnotations/manyLinesFromFileBegin.after.kt");
+                runTest("idea/testData/formatter/fileAnnotations/manyLinesFromFileBegin.after.kt");
             }
         }
 
-        @TestMetadata("testData/formatter/modifierList")
+        @TestMetadata("idea/testData/formatter/modifierList")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class ModifierList extends AbstractFormatterTest {
@@ -1015,91 +1045,91 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInModifierList() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/modifierList"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/modifierList"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
             }
 
             @TestMetadata("funAnnotationBeforeAnnotation.after.kt")
             public void testFunAnnotationBeforeAnnotation() throws Exception {
-                runTest("testData/formatter/modifierList/funAnnotationBeforeAnnotation.after.kt");
+                runTest("idea/testData/formatter/modifierList/funAnnotationBeforeAnnotation.after.kt");
             }
 
             @TestMetadata("funAnnotationBeforeAnnotationEntry.after.kt")
             public void testFunAnnotationBeforeAnnotationEntry() throws Exception {
-                runTest("testData/formatter/modifierList/funAnnotationBeforeAnnotationEntry.after.kt");
+                runTest("idea/testData/formatter/modifierList/funAnnotationBeforeAnnotationEntry.after.kt");
             }
 
             @TestMetadata("funAnnotationBeforeModifiers.after.kt")
             public void testFunAnnotationBeforeModifiers() throws Exception {
-                runTest("testData/formatter/modifierList/funAnnotationBeforeModifiers.after.kt");
+                runTest("idea/testData/formatter/modifierList/funAnnotationBeforeModifiers.after.kt");
             }
 
             @TestMetadata("funAnnotationEntryBeforeAnnotation.after.kt")
             public void testFunAnnotationEntryBeforeAnnotation() throws Exception {
-                runTest("testData/formatter/modifierList/funAnnotationEntryBeforeAnnotation.after.kt");
+                runTest("idea/testData/formatter/modifierList/funAnnotationEntryBeforeAnnotation.after.kt");
             }
 
             @TestMetadata("funAnnotationEntryBeforeAnnotationEntry.after.kt")
             public void testFunAnnotationEntryBeforeAnnotationEntry() throws Exception {
-                runTest("testData/formatter/modifierList/funAnnotationEntryBeforeAnnotationEntry.after.kt");
+                runTest("idea/testData/formatter/modifierList/funAnnotationEntryBeforeAnnotationEntry.after.kt");
             }
 
             @TestMetadata("funAnnotationEntryBeforeModifiers.after.kt")
             public void testFunAnnotationEntryBeforeModifiers() throws Exception {
-                runTest("testData/formatter/modifierList/funAnnotationEntryBeforeModifiers.after.kt");
+                runTest("idea/testData/formatter/modifierList/funAnnotationEntryBeforeModifiers.after.kt");
             }
 
             @TestMetadata("funModifierBeforeAnnotation.after.kt")
             public void testFunModifierBeforeAnnotation() throws Exception {
-                runTest("testData/formatter/modifierList/funModifierBeforeAnnotation.after.kt");
+                runTest("idea/testData/formatter/modifierList/funModifierBeforeAnnotation.after.kt");
             }
 
             @TestMetadata("funModifierBeforeAnnotationEntry.after.kt")
             public void testFunModifierBeforeAnnotationEntry() throws Exception {
-                runTest("testData/formatter/modifierList/funModifierBeforeAnnotationEntry.after.kt");
+                runTest("idea/testData/formatter/modifierList/funModifierBeforeAnnotationEntry.after.kt");
             }
 
             @TestMetadata("funModifierBeforeModifiers.after.kt")
             public void testFunModifierBeforeModifiers() throws Exception {
-                runTest("testData/formatter/modifierList/funModifierBeforeModifiers.after.kt");
+                runTest("idea/testData/formatter/modifierList/funModifierBeforeModifiers.after.kt");
             }
 
             @TestMetadata("funTheOnlyModifier.after.kt")
             public void testFunTheOnlyModifier() throws Exception {
-                runTest("testData/formatter/modifierList/funTheOnlyModifier.after.kt");
+                runTest("idea/testData/formatter/modifierList/funTheOnlyModifier.after.kt");
             }
 
             @TestMetadata("memberFunTheOnlyModifier.after.kt")
             public void testMemberFunTheOnlyModifier() throws Exception {
-                runTest("testData/formatter/modifierList/memberFunTheOnlyModifier.after.kt");
+                runTest("idea/testData/formatter/modifierList/memberFunTheOnlyModifier.after.kt");
             }
 
             @TestMetadata("memberValTheOnlyModifier.after.kt")
             public void testMemberValTheOnlyModifier() throws Exception {
-                runTest("testData/formatter/modifierList/memberValTheOnlyModifier.after.kt");
+                runTest("idea/testData/formatter/modifierList/memberValTheOnlyModifier.after.kt");
             }
 
             @TestMetadata("memberVarTheOnlyModifier.after.kt")
             public void testMemberVarTheOnlyModifier() throws Exception {
-                runTest("testData/formatter/modifierList/memberVarTheOnlyModifier.after.kt");
+                runTest("idea/testData/formatter/modifierList/memberVarTheOnlyModifier.after.kt");
             }
 
             @TestMetadata("secondMemberFunTheOnlyModifier.after.kt")
             public void testSecondMemberFunTheOnlyModifier() throws Exception {
-                runTest("testData/formatter/modifierList/secondMemberFunTheOnlyModifier.after.kt");
+                runTest("idea/testData/formatter/modifierList/secondMemberFunTheOnlyModifier.after.kt");
             }
 
             @TestMetadata("secondMemberValTheOnlyModifier.after.kt")
             public void testSecondMemberValTheOnlyModifier() throws Exception {
-                runTest("testData/formatter/modifierList/secondMemberValTheOnlyModifier.after.kt");
+                runTest("idea/testData/formatter/modifierList/secondMemberValTheOnlyModifier.after.kt");
             }
 
             @TestMetadata("secondMemberVarTheOnlyModifier.after.kt")
             public void testSecondMemberVarTheOnlyModifier() throws Exception {
-                runTest("testData/formatter/modifierList/secondMemberVarTheOnlyModifier.after.kt");
+                runTest("idea/testData/formatter/modifierList/secondMemberVarTheOnlyModifier.after.kt");
             }
         }
 
-        @TestMetadata("testData/formatter/parameterList")
+        @TestMetadata("idea/testData/formatter/parameterList")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class ParameterList extends AbstractFormatterTest {
@@ -1108,66 +1138,66 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInParameterList() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/parameterList"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/parameterList"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
             }
 
             @TestMetadata("ArgumentListChopAsNeeded.after.kt")
             public void testArgumentListChopAsNeeded() throws Exception {
-                runTest("testData/formatter/parameterList/ArgumentListChopAsNeeded.after.kt");
+                runTest("idea/testData/formatter/parameterList/ArgumentListChopAsNeeded.after.kt");
             }
 
             @TestMetadata("ArgumentListDoNotWrap.after.kt")
             public void testArgumentListDoNotWrap() throws Exception {
-                runTest("testData/formatter/parameterList/ArgumentListDoNotWrap.after.kt");
+                runTest("idea/testData/formatter/parameterList/ArgumentListDoNotWrap.after.kt");
             }
 
             @TestMetadata("ArgumentListWrapAlways.after.kt")
             public void testArgumentListWrapAlways() throws Exception {
-                runTest("testData/formatter/parameterList/ArgumentListWrapAlways.after.kt");
+                runTest("idea/testData/formatter/parameterList/ArgumentListWrapAlways.after.kt");
             }
 
             @TestMetadata("ArgumentListWrapAsNeeded.after.kt")
             public void testArgumentListWrapAsNeeded() throws Exception {
-                runTest("testData/formatter/parameterList/ArgumentListWrapAsNeeded.after.kt");
+                runTest("idea/testData/formatter/parameterList/ArgumentListWrapAsNeeded.after.kt");
             }
 
             @TestMetadata("ArgumentListWrapLParen.after.kt")
             public void testArgumentListWrapLParen() throws Exception {
-                runTest("testData/formatter/parameterList/ArgumentListWrapLParen.after.kt");
+                runTest("idea/testData/formatter/parameterList/ArgumentListWrapLParen.after.kt");
             }
 
             @TestMetadata("DefaultParameterValues.after.kt")
             public void testDefaultParameterValues() throws Exception {
-                runTest("testData/formatter/parameterList/DefaultParameterValues.after.kt");
+                runTest("idea/testData/formatter/parameterList/DefaultParameterValues.after.kt");
             }
 
             @TestMetadata("KT19727.after.kt")
             public void testKT19727() throws Exception {
-                runTest("testData/formatter/parameterList/KT19727.after.kt");
+                runTest("idea/testData/formatter/parameterList/KT19727.after.kt");
             }
 
             @TestMetadata("ParameterListChopAsNeeded.after.kt")
             public void testParameterListChopAsNeeded() throws Exception {
-                runTest("testData/formatter/parameterList/ParameterListChopAsNeeded.after.kt");
+                runTest("idea/testData/formatter/parameterList/ParameterListChopAsNeeded.after.kt");
             }
 
             @TestMetadata("ParameterListDoNotWrap.after.kt")
             public void testParameterListDoNotWrap() throws Exception {
-                runTest("testData/formatter/parameterList/ParameterListDoNotWrap.after.kt");
+                runTest("idea/testData/formatter/parameterList/ParameterListDoNotWrap.after.kt");
             }
 
             @TestMetadata("ParameterListWrapAlways.after.kt")
             public void testParameterListWrapAlways() throws Exception {
-                runTest("testData/formatter/parameterList/ParameterListWrapAlways.after.kt");
+                runTest("idea/testData/formatter/parameterList/ParameterListWrapAlways.after.kt");
             }
 
             @TestMetadata("ParameterListWrapAsNeeded.after.kt")
             public void testParameterListWrapAsNeeded() throws Exception {
-                runTest("testData/formatter/parameterList/ParameterListWrapAsNeeded.after.kt");
+                runTest("idea/testData/formatter/parameterList/ParameterListWrapAsNeeded.after.kt");
             }
         }
 
-        @TestMetadata("testData/formatter/trailingComma")
+        @TestMetadata("idea/testData/formatter/trailingComma")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class TrailingComma extends AbstractFormatterTest {
@@ -1176,10 +1206,10 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInTrailingComma() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
             }
 
-            @TestMetadata("testData/formatter/trailingComma/collectionLiteralExpression")
+            @TestMetadata("idea/testData/formatter/trailingComma/collectionLiteralExpression")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class CollectionLiteralExpression extends AbstractFormatterTest {
@@ -1188,16 +1218,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
                 }
 
                 public void testAllFilesPresentInCollectionLiteralExpression() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/collectionLiteralExpression"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/collectionLiteralExpression"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
                 }
 
                 @TestMetadata("CollectionLiteralInAnnotation.after.kt")
                 public void testCollectionLiteralInAnnotation() throws Exception {
-                    runTest("testData/formatter/trailingComma/collectionLiteralExpression/CollectionLiteralInAnnotation.after.kt");
+                    runTest("idea/testData/formatter/trailingComma/collectionLiteralExpression/CollectionLiteralInAnnotation.after.kt");
                 }
             }
 
-            @TestMetadata("testData/formatter/trailingComma/destructuringDeclarations")
+            @TestMetadata("idea/testData/formatter/trailingComma/destructuringDeclarations")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class DestructuringDeclarations extends AbstractFormatterTest {
@@ -1206,21 +1236,21 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
                 }
 
                 public void testAllFilesPresentInDestructuringDeclarations() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/destructuringDeclarations"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/destructuringDeclarations"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
                 }
 
                 @TestMetadata("DestructuringDeclarationsInLambda.after.kt")
                 public void testDestructuringDeclarationsInLambda() throws Exception {
-                    runTest("testData/formatter/trailingComma/destructuringDeclarations/DestructuringDeclarationsInLambda.after.kt");
+                    runTest("idea/testData/formatter/trailingComma/destructuringDeclarations/DestructuringDeclarationsInLambda.after.kt");
                 }
 
                 @TestMetadata("MultiVariableDeclaration.after.kt")
                 public void testMultiVariableDeclaration() throws Exception {
-                    runTest("testData/formatter/trailingComma/destructuringDeclarations/MultiVariableDeclaration.after.kt");
+                    runTest("idea/testData/formatter/trailingComma/destructuringDeclarations/MultiVariableDeclaration.after.kt");
                 }
             }
 
-            @TestMetadata("testData/formatter/trailingComma/enumEntry")
+            @TestMetadata("idea/testData/formatter/trailingComma/enumEntry")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class EnumEntry extends AbstractFormatterTest {
@@ -1229,16 +1259,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
                 }
 
                 public void testAllFilesPresentInEnumEntry() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/enumEntry"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/enumEntry"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
                 }
 
                 @TestMetadata("Enum.after.kt")
                 public void testEnum() throws Exception {
-                    runTest("testData/formatter/trailingComma/enumEntry/Enum.after.kt");
+                    runTest("idea/testData/formatter/trailingComma/enumEntry/Enum.after.kt");
                 }
             }
 
-            @TestMetadata("testData/formatter/trailingComma/indices")
+            @TestMetadata("idea/testData/formatter/trailingComma/indices")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class Indices extends AbstractFormatterTest {
@@ -1247,16 +1277,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
                 }
 
                 public void testAllFilesPresentInIndices() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/indices"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/indices"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
                 }
 
                 @TestMetadata("IndicesAccess.after.kt")
                 public void testIndicesAccess() throws Exception {
-                    runTest("testData/formatter/trailingComma/indices/IndicesAccess.after.kt");
+                    runTest("idea/testData/formatter/trailingComma/indices/IndicesAccess.after.kt");
                 }
             }
 
-            @TestMetadata("testData/formatter/trailingComma/lambdaParameters")
+            @TestMetadata("idea/testData/formatter/trailingComma/lambdaParameters")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class LambdaParameters extends AbstractFormatterTest {
@@ -1265,16 +1295,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
                 }
 
                 public void testAllFilesPresentInLambdaParameters() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/lambdaParameters"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/lambdaParameters"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
                 }
 
                 @TestMetadata("LambdaParameterList.after.kt")
                 public void testLambdaParameterList() throws Exception {
-                    runTest("testData/formatter/trailingComma/lambdaParameters/LambdaParameterList.after.kt");
+                    runTest("idea/testData/formatter/trailingComma/lambdaParameters/LambdaParameterList.after.kt");
                 }
             }
 
-            @TestMetadata("testData/formatter/trailingComma/typeArguments")
+            @TestMetadata("idea/testData/formatter/trailingComma/typeArguments")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class TypeArguments extends AbstractFormatterTest {
@@ -1283,16 +1313,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
                 }
 
                 public void testAllFilesPresentInTypeArguments() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/typeArguments"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/typeArguments"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
                 }
 
                 @TestMetadata("TypeArgumentList.after.kt")
                 public void testTypeArgumentList() throws Exception {
-                    runTest("testData/formatter/trailingComma/typeArguments/TypeArgumentList.after.kt");
+                    runTest("idea/testData/formatter/trailingComma/typeArguments/TypeArgumentList.after.kt");
                 }
             }
 
-            @TestMetadata("testData/formatter/trailingComma/typeParameters")
+            @TestMetadata("idea/testData/formatter/trailingComma/typeParameters")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class TypeParameters extends AbstractFormatterTest {
@@ -1301,16 +1331,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
                 }
 
                 public void testAllFilesPresentInTypeParameters() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/typeParameters"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/typeParameters"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
                 }
 
                 @TestMetadata("TypeParameterList.after.kt")
                 public void testTypeParameterList() throws Exception {
-                    runTest("testData/formatter/trailingComma/typeParameters/TypeParameterList.after.kt");
+                    runTest("idea/testData/formatter/trailingComma/typeParameters/TypeParameterList.after.kt");
                 }
             }
 
-            @TestMetadata("testData/formatter/trailingComma/valueArguments")
+            @TestMetadata("idea/testData/formatter/trailingComma/valueArguments")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class ValueArguments extends AbstractFormatterTest {
@@ -1319,31 +1349,31 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
                 }
 
                 public void testAllFilesPresentInValueArguments() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/valueArguments"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/valueArguments"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
                 }
 
                 @TestMetadata("ArgumentListChopAsNeeded.after.kt")
                 public void testArgumentListChopAsNeeded() throws Exception {
-                    runTest("testData/formatter/trailingComma/valueArguments/ArgumentListChopAsNeeded.after.kt");
+                    runTest("idea/testData/formatter/trailingComma/valueArguments/ArgumentListChopAsNeeded.after.kt");
                 }
 
                 @TestMetadata("ArgumentListDoNotWrap.after.kt")
                 public void testArgumentListDoNotWrap() throws Exception {
-                    runTest("testData/formatter/trailingComma/valueArguments/ArgumentListDoNotWrap.after.kt");
+                    runTest("idea/testData/formatter/trailingComma/valueArguments/ArgumentListDoNotWrap.after.kt");
                 }
 
                 @TestMetadata("ArgumentListWrapAlways.after.kt")
                 public void testArgumentListWrapAlways() throws Exception {
-                    runTest("testData/formatter/trailingComma/valueArguments/ArgumentListWrapAlways.after.kt");
+                    runTest("idea/testData/formatter/trailingComma/valueArguments/ArgumentListWrapAlways.after.kt");
                 }
 
                 @TestMetadata("ArgumentListWrapAsNeeded.after.kt")
                 public void testArgumentListWrapAsNeeded() throws Exception {
-                    runTest("testData/formatter/trailingComma/valueArguments/ArgumentListWrapAsNeeded.after.kt");
+                    runTest("idea/testData/formatter/trailingComma/valueArguments/ArgumentListWrapAsNeeded.after.kt");
                 }
             }
 
-            @TestMetadata("testData/formatter/trailingComma/valueParameters")
+            @TestMetadata("idea/testData/formatter/trailingComma/valueParameters")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class ValueParameters extends AbstractFormatterTest {
@@ -1352,36 +1382,36 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
                 }
 
                 public void testAllFilesPresentInValueParameters() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/valueParameters"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/valueParameters"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
                 }
 
                 @TestMetadata("LambdaValueParameters.after.kt")
                 public void testLambdaValueParameters() throws Exception {
-                    runTest("testData/formatter/trailingComma/valueParameters/LambdaValueParameters.after.kt");
+                    runTest("idea/testData/formatter/trailingComma/valueParameters/LambdaValueParameters.after.kt");
                 }
 
                 @TestMetadata("ParameterListChopAsNeeded.after.kt")
                 public void testParameterListChopAsNeeded() throws Exception {
-                    runTest("testData/formatter/trailingComma/valueParameters/ParameterListChopAsNeeded.after.kt");
+                    runTest("idea/testData/formatter/trailingComma/valueParameters/ParameterListChopAsNeeded.after.kt");
                 }
 
                 @TestMetadata("ParameterListDoNotWrap.after.kt")
                 public void testParameterListDoNotWrap() throws Exception {
-                    runTest("testData/formatter/trailingComma/valueParameters/ParameterListDoNotWrap.after.kt");
+                    runTest("idea/testData/formatter/trailingComma/valueParameters/ParameterListDoNotWrap.after.kt");
                 }
 
                 @TestMetadata("ParameterListWrapAlways.after.kt")
                 public void testParameterListWrapAlways() throws Exception {
-                    runTest("testData/formatter/trailingComma/valueParameters/ParameterListWrapAlways.after.kt");
+                    runTest("idea/testData/formatter/trailingComma/valueParameters/ParameterListWrapAlways.after.kt");
                 }
 
                 @TestMetadata("ParameterListWrapAsNeeded.after.kt")
                 public void testParameterListWrapAsNeeded() throws Exception {
-                    runTest("testData/formatter/trailingComma/valueParameters/ParameterListWrapAsNeeded.after.kt");
+                    runTest("idea/testData/formatter/trailingComma/valueParameters/ParameterListWrapAsNeeded.after.kt");
                 }
             }
 
-            @TestMetadata("testData/formatter/trailingComma/whenEntry")
+            @TestMetadata("idea/testData/formatter/trailingComma/whenEntry")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class WhenEntry extends AbstractFormatterTest {
@@ -1390,18 +1420,18 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
                 }
 
                 public void testAllFilesPresentInWhenEntry() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/whenEntry"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/whenEntry"), Pattern.compile("^([^\\.]+)\\.after\\.kt.*$"), null, true);
                 }
 
                 @TestMetadata("WhenEntry.after.kt")
                 public void testWhenEntry() throws Exception {
-                    runTest("testData/formatter/trailingComma/whenEntry/WhenEntry.after.kt");
+                    runTest("idea/testData/formatter/trailingComma/whenEntry/WhenEntry.after.kt");
                 }
             }
         }
     }
 
-    @TestMetadata("testData/formatter/trailingComma")
+    @TestMetadata("idea/testData/formatter/trailingComma")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class FormatterCallSite extends AbstractFormatterTest {
@@ -1410,10 +1440,10 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
         }
 
         public void testAllFilesPresentInFormatterCallSite() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true);
         }
 
-        @TestMetadata("testData/formatter/trailingComma/collectionLiteralExpression")
+        @TestMetadata("idea/testData/formatter/trailingComma/collectionLiteralExpression")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class CollectionLiteralExpression extends AbstractFormatterTest {
@@ -1422,16 +1452,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInCollectionLiteralExpression() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/collectionLiteralExpression"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/collectionLiteralExpression"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true);
             }
 
             @TestMetadata("CollectionLiteralInAnnotation.call.after.kt")
             public void testCollectionLiteralInAnnotation() throws Exception {
-                runTest("testData/formatter/trailingComma/collectionLiteralExpression/CollectionLiteralInAnnotation.call.after.kt");
+                runTest("idea/testData/formatter/trailingComma/collectionLiteralExpression/CollectionLiteralInAnnotation.call.after.kt");
             }
         }
 
-        @TestMetadata("testData/formatter/trailingComma/destructuringDeclarations")
+        @TestMetadata("idea/testData/formatter/trailingComma/destructuringDeclarations")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class DestructuringDeclarations extends AbstractFormatterTest {
@@ -1440,11 +1470,11 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInDestructuringDeclarations() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/destructuringDeclarations"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/destructuringDeclarations"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true);
             }
         }
 
-        @TestMetadata("testData/formatter/trailingComma/enumEntry")
+        @TestMetadata("idea/testData/formatter/trailingComma/enumEntry")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class EnumEntry extends AbstractFormatterTest {
@@ -1453,11 +1483,11 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInEnumEntry() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/enumEntry"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/enumEntry"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true);
             }
         }
 
-        @TestMetadata("testData/formatter/trailingComma/indices")
+        @TestMetadata("idea/testData/formatter/trailingComma/indices")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Indices extends AbstractFormatterTest {
@@ -1466,16 +1496,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInIndices() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/indices"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/indices"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true);
             }
 
             @TestMetadata("IndicesAccess.call.after.kt")
             public void testIndicesAccess() throws Exception {
-                runTest("testData/formatter/trailingComma/indices/IndicesAccess.call.after.kt");
+                runTest("idea/testData/formatter/trailingComma/indices/IndicesAccess.call.after.kt");
             }
         }
 
-        @TestMetadata("testData/formatter/trailingComma/lambdaParameters")
+        @TestMetadata("idea/testData/formatter/trailingComma/lambdaParameters")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class LambdaParameters extends AbstractFormatterTest {
@@ -1484,16 +1514,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInLambdaParameters() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/lambdaParameters"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/lambdaParameters"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true);
             }
 
             @TestMetadata("LambdaParameterList.call.after.kt")
             public void testLambdaParameterList() throws Exception {
-                runTest("testData/formatter/trailingComma/lambdaParameters/LambdaParameterList.call.after.kt");
+                runTest("idea/testData/formatter/trailingComma/lambdaParameters/LambdaParameterList.call.after.kt");
             }
         }
 
-        @TestMetadata("testData/formatter/trailingComma/typeArguments")
+        @TestMetadata("idea/testData/formatter/trailingComma/typeArguments")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class TypeArguments extends AbstractFormatterTest {
@@ -1502,16 +1532,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInTypeArguments() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/typeArguments"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/typeArguments"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true);
             }
 
             @TestMetadata("TypeArgumentList.call.after.kt")
             public void testTypeArgumentList() throws Exception {
-                runTest("testData/formatter/trailingComma/typeArguments/TypeArgumentList.call.after.kt");
+                runTest("idea/testData/formatter/trailingComma/typeArguments/TypeArgumentList.call.after.kt");
             }
         }
 
-        @TestMetadata("testData/formatter/trailingComma/typeParameters")
+        @TestMetadata("idea/testData/formatter/trailingComma/typeParameters")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class TypeParameters extends AbstractFormatterTest {
@@ -1520,16 +1550,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInTypeParameters() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/typeParameters"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/typeParameters"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true);
             }
 
             @TestMetadata("TypeParameterList.call.after.kt")
             public void testTypeParameterList() throws Exception {
-                runTest("testData/formatter/trailingComma/typeParameters/TypeParameterList.call.after.kt");
+                runTest("idea/testData/formatter/trailingComma/typeParameters/TypeParameterList.call.after.kt");
             }
         }
 
-        @TestMetadata("testData/formatter/trailingComma/valueArguments")
+        @TestMetadata("idea/testData/formatter/trailingComma/valueArguments")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class ValueArguments extends AbstractFormatterTest {
@@ -1538,16 +1568,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInValueArguments() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/valueArguments"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/valueArguments"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true);
             }
 
             @TestMetadata("ArgumentListWrapAsNeeded.call.after.kt")
             public void testArgumentListWrapAsNeeded() throws Exception {
-                runTest("testData/formatter/trailingComma/valueArguments/ArgumentListWrapAsNeeded.call.after.kt");
+                runTest("idea/testData/formatter/trailingComma/valueArguments/ArgumentListWrapAsNeeded.call.after.kt");
             }
         }
 
-        @TestMetadata("testData/formatter/trailingComma/valueParameters")
+        @TestMetadata("idea/testData/formatter/trailingComma/valueParameters")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class ValueParameters extends AbstractFormatterTest {
@@ -1556,16 +1586,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInValueParameters() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/valueParameters"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/valueParameters"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true);
             }
 
             @TestMetadata("ParameterListWrapAsNeeded.call.after.kt")
             public void testParameterListWrapAsNeeded() throws Exception {
-                runTest("testData/formatter/trailingComma/valueParameters/ParameterListWrapAsNeeded.call.after.kt");
+                runTest("idea/testData/formatter/trailingComma/valueParameters/ParameterListWrapAsNeeded.call.after.kt");
             }
         }
 
-        @TestMetadata("testData/formatter/trailingComma/whenEntry")
+        @TestMetadata("idea/testData/formatter/trailingComma/whenEntry")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class WhenEntry extends AbstractFormatterTest {
@@ -1574,12 +1604,12 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInWhenEntry() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/whenEntry"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/whenEntry"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.kt.*$"), null, true);
             }
         }
     }
 
-    @TestMetadata("testData/formatter")
+    @TestMetadata("idea/testData/formatter")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class FormatterInverted extends AbstractFormatterTest {
@@ -1588,270 +1618,270 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
         }
 
         public void testAllFilesPresentInFormatterInverted() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
         }
 
         @TestMetadata("AnonymousInitializersLineBreak.after.inv.kt")
         public void testAnonymousInitializersLineBreak() throws Exception {
-            runTest("testData/formatter/AnonymousInitializersLineBreak.after.inv.kt");
+            runTest("idea/testData/formatter/AnonymousInitializersLineBreak.after.inv.kt");
         }
 
         @TestMetadata("BinaryExpressions.after.inv.kt")
         public void testBinaryExpressions() throws Exception {
-            runTest("testData/formatter/BinaryExpressions.after.inv.kt");
+            runTest("idea/testData/formatter/BinaryExpressions.after.inv.kt");
         }
 
         @TestMetadata("BinaryExpressionsBoolean.after.inv.kt")
         public void testBinaryExpressionsBoolean() throws Exception {
-            runTest("testData/formatter/BinaryExpressionsBoolean.after.inv.kt");
+            runTest("idea/testData/formatter/BinaryExpressionsBoolean.after.inv.kt");
         }
 
         @TestMetadata("BinaryExpressionsWithoutAlignment.after.inv.kt")
         public void testBinaryExpressionsWithoutAlignment() throws Exception {
-            runTest("testData/formatter/BinaryExpressionsWithoutAlignment.after.inv.kt");
+            runTest("idea/testData/formatter/BinaryExpressionsWithoutAlignment.after.inv.kt");
         }
 
         @TestMetadata("CallLParenthOnNextLine.after.inv.kt")
         public void testCallLParenthOnNextLine() throws Exception {
-            runTest("testData/formatter/CallLParenthOnNextLine.after.inv.kt");
+            runTest("idea/testData/formatter/CallLParenthOnNextLine.after.inv.kt");
         }
 
         @TestMetadata("CallRParenthOnNextLine.after.inv.kt")
         public void testCallRParenthOnNextLine() throws Exception {
-            runTest("testData/formatter/CallRParenthOnNextLine.after.inv.kt");
+            runTest("idea/testData/formatter/CallRParenthOnNextLine.after.inv.kt");
         }
 
         @TestMetadata("CatchFinallyOnNewLine.after.inv.kt")
         public void testCatchFinallyOnNewLine() throws Exception {
-            runTest("testData/formatter/CatchFinallyOnNewLine.after.inv.kt");
+            runTest("idea/testData/formatter/CatchFinallyOnNewLine.after.inv.kt");
         }
 
         @TestMetadata("ClassLineBreak.after.inv.kt")
         public void testClassLineBreak() throws Exception {
-            runTest("testData/formatter/ClassLineBreak.after.inv.kt");
+            runTest("idea/testData/formatter/ClassLineBreak.after.inv.kt");
         }
 
         @TestMetadata("ColonSpaces.after.inv.kt")
         public void testColonSpaces() throws Exception {
-            runTest("testData/formatter/ColonSpaces.after.inv.kt");
+            runTest("idea/testData/formatter/ColonSpaces.after.inv.kt");
         }
 
         @TestMetadata("ContinuationIndentForExpressionBodies.after.inv.kt")
         public void testContinuationIndentForExpressionBodies() throws Exception {
-            runTest("testData/formatter/ContinuationIndentForExpressionBodies.after.inv.kt");
+            runTest("idea/testData/formatter/ContinuationIndentForExpressionBodies.after.inv.kt");
         }
 
         @TestMetadata("ContinuationIndentInAssigments.after.inv.kt")
         public void testContinuationIndentInAssigments() throws Exception {
-            runTest("testData/formatter/ContinuationIndentInAssigments.after.inv.kt");
+            runTest("idea/testData/formatter/ContinuationIndentInAssigments.after.inv.kt");
         }
 
         @TestMetadata("DelegationList.after.inv.kt")
         public void testDelegationList() throws Exception {
-            runTest("testData/formatter/DelegationList.after.inv.kt");
+            runTest("idea/testData/formatter/DelegationList.after.inv.kt");
         }
 
         @TestMetadata("DoWhileLineBreak.after.inv.kt")
         public void testDoWhileLineBreak() throws Exception {
-            runTest("testData/formatter/DoWhileLineBreak.after.inv.kt");
+            runTest("idea/testData/formatter/DoWhileLineBreak.after.inv.kt");
         }
 
         @TestMetadata("ElseOnNewLine.after.inv.kt")
         public void testElseOnNewLine() throws Exception {
-            runTest("testData/formatter/ElseOnNewLine.after.inv.kt");
+            runTest("idea/testData/formatter/ElseOnNewLine.after.inv.kt");
         }
 
         @TestMetadata("Elvis.after.inv.kt")
         public void testElvis() throws Exception {
-            runTest("testData/formatter/Elvis.after.inv.kt");
+            runTest("idea/testData/formatter/Elvis.after.inv.kt");
         }
 
         @TestMetadata("ElvisContinuationIndentOptions.after.inv.kt")
         public void testElvisContinuationIndentOptions() throws Exception {
-            runTest("testData/formatter/ElvisContinuationIndentOptions.after.inv.kt");
+            runTest("idea/testData/formatter/ElvisContinuationIndentOptions.after.inv.kt");
         }
 
         @TestMetadata("ElvisIndent.after.inv.kt")
         public void testElvisIndent() throws Exception {
-            runTest("testData/formatter/ElvisIndent.after.inv.kt");
+            runTest("idea/testData/formatter/ElvisIndent.after.inv.kt");
         }
 
         @TestMetadata("EmptyBlocks.after.inv.kt")
         public void testEmptyBlocks() throws Exception {
-            runTest("testData/formatter/EmptyBlocks.after.inv.kt");
+            runTest("idea/testData/formatter/EmptyBlocks.after.inv.kt");
         }
 
         @TestMetadata("EmptyLineBetweenEnumEntries.after.inv.kt")
         public void testEmptyLineBetweenEnumEntries() throws Exception {
-            runTest("testData/formatter/EmptyLineBetweenEnumEntries.after.inv.kt");
+            runTest("idea/testData/formatter/EmptyLineBetweenEnumEntries.after.inv.kt");
         }
 
         @TestMetadata("ExtendsListAlignEnum.after.inv.kt")
         public void testExtendsListAlignEnum() throws Exception {
-            runTest("testData/formatter/ExtendsListAlignEnum.after.inv.kt");
+            runTest("idea/testData/formatter/ExtendsListAlignEnum.after.inv.kt");
         }
 
         @TestMetadata("ForLineBreak.after.inv.kt")
         public void testForLineBreak() throws Exception {
-            runTest("testData/formatter/ForLineBreak.after.inv.kt");
+            runTest("idea/testData/formatter/ForLineBreak.after.inv.kt");
         }
 
         @TestMetadata("FormatFirstColumnComments.after.inv.kt")
         public void testFormatFirstColumnComments() throws Exception {
-            runTest("testData/formatter/FormatFirstColumnComments.after.inv.kt");
+            runTest("idea/testData/formatter/FormatFirstColumnComments.after.inv.kt");
         }
 
         @TestMetadata("FormatFirstColumnCommentsBeforeDeclaration.after.inv.kt")
         public void testFormatFirstColumnCommentsBeforeDeclaration() throws Exception {
-            runTest("testData/formatter/FormatFirstColumnCommentsBeforeDeclaration.after.inv.kt");
+            runTest("idea/testData/formatter/FormatFirstColumnCommentsBeforeDeclaration.after.inv.kt");
         }
 
         @TestMetadata("FunctionLineBreak.after.inv.kt")
         public void testFunctionLineBreak() throws Exception {
-            runTest("testData/formatter/FunctionLineBreak.after.inv.kt");
+            runTest("idea/testData/formatter/FunctionLineBreak.after.inv.kt");
         }
 
         @TestMetadata("FunctionalType.after.inv.kt")
         public void testFunctionalType() throws Exception {
-            runTest("testData/formatter/FunctionalType.after.inv.kt");
+            runTest("idea/testData/formatter/FunctionalType.after.inv.kt");
         }
 
         @TestMetadata("IfConditionIndent.after.inv.kt")
         public void testIfConditionIndent() throws Exception {
-            runTest("testData/formatter/IfConditionIndent.after.inv.kt");
+            runTest("idea/testData/formatter/IfConditionIndent.after.inv.kt");
         }
 
         @TestMetadata("IfElseWithTrickyComments.after.inv.kt")
         public void testIfElseWithTrickyComments() throws Exception {
-            runTest("testData/formatter/IfElseWithTrickyComments.after.inv.kt");
+            runTest("idea/testData/formatter/IfElseWithTrickyComments.after.inv.kt");
         }
 
         @TestMetadata("KeepLineBreak.after.inv.kt")
         public void testKeepLineBreak() throws Exception {
-            runTest("testData/formatter/KeepLineBreak.after.inv.kt");
+            runTest("idea/testData/formatter/KeepLineBreak.after.inv.kt");
         }
 
         @TestMetadata("LambdaArrow.after.inv.kt")
         public void testLambdaArrow() throws Exception {
-            runTest("testData/formatter/LambdaArrow.after.inv.kt");
+            runTest("idea/testData/formatter/LambdaArrow.after.inv.kt");
         }
 
         @TestMetadata("MethodLParenthOnNextLine.after.inv.kt")
         public void testMethodLParenthOnNextLine() throws Exception {
-            runTest("testData/formatter/MethodLParenthOnNextLine.after.inv.kt");
+            runTest("idea/testData/formatter/MethodLParenthOnNextLine.after.inv.kt");
         }
 
         @TestMetadata("MethodRParenthOnNextLine.after.inv.kt")
         public void testMethodRParenthOnNextLine() throws Exception {
-            runTest("testData/formatter/MethodRParenthOnNextLine.after.inv.kt");
+            runTest("idea/testData/formatter/MethodRParenthOnNextLine.after.inv.kt");
         }
 
         @TestMetadata("MultilineFunctionLiteralWithParams.after.inv.kt")
         public void testMultilineFunctionLiteralWithParams() throws Exception {
-            runTest("testData/formatter/MultilineFunctionLiteralWithParams.after.inv.kt");
+            runTest("idea/testData/formatter/MultilineFunctionLiteralWithParams.after.inv.kt");
         }
 
         @TestMetadata("Parameters.after.inv.kt")
         public void testParameters() throws Exception {
-            runTest("testData/formatter/Parameters.after.inv.kt");
+            runTest("idea/testData/formatter/Parameters.after.inv.kt");
         }
 
         @TestMetadata("RightBracketOnNewLine.after.inv.kt")
         public void testRightBracketOnNewLine() throws Exception {
-            runTest("testData/formatter/RightBracketOnNewLine.after.inv.kt");
+            runTest("idea/testData/formatter/RightBracketOnNewLine.after.inv.kt");
         }
 
         @TestMetadata("secondaryCtorLineBreak.after.inv.kt")
         public void testSecondaryCtorLineBreak() throws Exception {
-            runTest("testData/formatter/secondaryCtorLineBreak.after.inv.kt");
+            runTest("idea/testData/formatter/secondaryCtorLineBreak.after.inv.kt");
         }
 
         @TestMetadata("SingleLineFunctionLiteral.after.inv.kt")
         public void testSingleLineFunctionLiteral() throws Exception {
-            runTest("testData/formatter/SingleLineFunctionLiteral.after.inv.kt");
+            runTest("idea/testData/formatter/SingleLineFunctionLiteral.after.inv.kt");
         }
 
         @TestMetadata("SpaceAroundExtendColon.after.inv.kt")
         public void testSpaceAroundExtendColon() throws Exception {
-            runTest("testData/formatter/SpaceAroundExtendColon.after.inv.kt");
+            runTest("idea/testData/formatter/SpaceAroundExtendColon.after.inv.kt");
         }
 
         @TestMetadata("SpaceAroundExtendColonInObjects.after.inv.kt")
         public void testSpaceAroundExtendColonInObjects() throws Exception {
-            runTest("testData/formatter/SpaceAroundExtendColonInObjects.after.inv.kt");
+            runTest("idea/testData/formatter/SpaceAroundExtendColonInObjects.after.inv.kt");
         }
 
         @TestMetadata("SpaceAroundExtendColonInSecondaryCtr.after.inv.kt")
         public void testSpaceAroundExtendColonInSecondaryCtr() throws Exception {
-            runTest("testData/formatter/SpaceAroundExtendColonInSecondaryCtr.after.inv.kt");
+            runTest("idea/testData/formatter/SpaceAroundExtendColonInSecondaryCtr.after.inv.kt");
         }
 
         @TestMetadata("SpaceBeforeCatchParentheses.after.inv.kt")
         public void testSpaceBeforeCatchParentheses() throws Exception {
-            runTest("testData/formatter/SpaceBeforeCatchParentheses.after.inv.kt");
+            runTest("idea/testData/formatter/SpaceBeforeCatchParentheses.after.inv.kt");
         }
 
         @TestMetadata("SpaceBeforeForParentheses.after.inv.kt")
         public void testSpaceBeforeForParentheses() throws Exception {
-            runTest("testData/formatter/SpaceBeforeForParentheses.after.inv.kt");
+            runTest("idea/testData/formatter/SpaceBeforeForParentheses.after.inv.kt");
         }
 
         @TestMetadata("SpaceBeforeIfParentheses.after.inv.kt")
         public void testSpaceBeforeIfParentheses() throws Exception {
-            runTest("testData/formatter/SpaceBeforeIfParentheses.after.inv.kt");
+            runTest("idea/testData/formatter/SpaceBeforeIfParentheses.after.inv.kt");
         }
 
         @TestMetadata("SpaceBeforeWhenParentheses.after.inv.kt")
         public void testSpaceBeforeWhenParentheses() throws Exception {
-            runTest("testData/formatter/SpaceBeforeWhenParentheses.after.inv.kt");
+            runTest("idea/testData/formatter/SpaceBeforeWhenParentheses.after.inv.kt");
         }
 
         @TestMetadata("SpaceBeforeWhileParentheses.after.inv.kt")
         public void testSpaceBeforeWhileParentheses() throws Exception {
-            runTest("testData/formatter/SpaceBeforeWhileParentheses.after.inv.kt");
+            runTest("idea/testData/formatter/SpaceBeforeWhileParentheses.after.inv.kt");
         }
 
         @TestMetadata("SpacesAroundOperations.after.inv.kt")
         public void testSpacesAroundOperations() throws Exception {
-            runTest("testData/formatter/SpacesAroundOperations.after.inv.kt");
+            runTest("idea/testData/formatter/SpacesAroundOperations.after.inv.kt");
         }
 
         @TestMetadata("SpacesAroundUnaryOperations.after.inv.kt")
         public void testSpacesAroundUnaryOperations() throws Exception {
-            runTest("testData/formatter/SpacesAroundUnaryOperations.after.inv.kt");
+            runTest("idea/testData/formatter/SpacesAroundUnaryOperations.after.inv.kt");
         }
 
         @TestMetadata("TryCatchLineBreak.after.inv.kt")
         public void testTryCatchLineBreak() throws Exception {
-            runTest("testData/formatter/TryCatchLineBreak.after.inv.kt");
+            runTest("idea/testData/formatter/TryCatchLineBreak.after.inv.kt");
         }
 
         @TestMetadata("When.after.inv.kt")
         public void testWhen() throws Exception {
-            runTest("testData/formatter/When.after.inv.kt");
+            runTest("idea/testData/formatter/When.after.inv.kt");
         }
 
         @TestMetadata("WhenArrow.after.inv.kt")
         public void testWhenArrow() throws Exception {
-            runTest("testData/formatter/WhenArrow.after.inv.kt");
+            runTest("idea/testData/formatter/WhenArrow.after.inv.kt");
         }
 
         @TestMetadata("WhenLineBreak.after.inv.kt")
         public void testWhenLineBreak() throws Exception {
-            runTest("testData/formatter/WhenLineBreak.after.inv.kt");
+            runTest("idea/testData/formatter/WhenLineBreak.after.inv.kt");
         }
 
         @TestMetadata("WhileLineBreak.after.inv.kt")
         public void testWhileLineBreak() throws Exception {
-            runTest("testData/formatter/WhileLineBreak.after.inv.kt");
+            runTest("idea/testData/formatter/WhileLineBreak.after.inv.kt");
         }
 
         @TestMetadata("WhileOnNewLine.after.inv.kt")
         public void testWhileOnNewLine() throws Exception {
-            runTest("testData/formatter/WhileOnNewLine.after.inv.kt");
+            runTest("idea/testData/formatter/WhileOnNewLine.after.inv.kt");
         }
 
-        @TestMetadata("testData/formatter/callChain")
+        @TestMetadata("idea/testData/formatter/callChain")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class CallChain extends AbstractFormatterTest {
@@ -1860,51 +1890,51 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInCallChain() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/callChain"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/callChain"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
             }
 
             @TestMetadata("CallChainWrapping.after.inv.kt")
             public void testCallChainWrapping() throws Exception {
-                runTest("testData/formatter/callChain/CallChainWrapping.after.inv.kt");
+                runTest("idea/testData/formatter/callChain/CallChainWrapping.after.inv.kt");
             }
 
             @TestMetadata("CallChainWrapping2.after.inv.kt")
             public void testCallChainWrapping2() throws Exception {
-                runTest("testData/formatter/callChain/CallChainWrapping2.after.inv.kt");
+                runTest("idea/testData/formatter/callChain/CallChainWrapping2.after.inv.kt");
             }
 
             @TestMetadata("CallChainWrappingChopDown.after.inv.kt")
             public void testCallChainWrappingChopDown() throws Exception {
-                runTest("testData/formatter/callChain/CallChainWrappingChopDown.after.inv.kt");
+                runTest("idea/testData/formatter/callChain/CallChainWrappingChopDown.after.inv.kt");
             }
 
             @TestMetadata("CallChainWrappingInElvis.after.inv.kt")
             public void testCallChainWrappingInElvis() throws Exception {
-                runTest("testData/formatter/callChain/CallChainWrappingInElvis.after.inv.kt");
+                runTest("idea/testData/formatter/callChain/CallChainWrappingInElvis.after.inv.kt");
             }
 
             @TestMetadata("ConsecutiveSafeCallsIndent.after.inv.kt")
             public void testConsecutiveSafeCallsIndent() throws Exception {
-                runTest("testData/formatter/callChain/ConsecutiveSafeCallsIndent.after.inv.kt");
+                runTest("idea/testData/formatter/callChain/ConsecutiveSafeCallsIndent.after.inv.kt");
             }
 
             @TestMetadata("ContinuationIndentForChainedCalls.after.inv.kt")
             public void testContinuationIndentForChainedCalls() throws Exception {
-                runTest("testData/formatter/callChain/ContinuationIndentForChainedCalls.after.inv.kt");
+                runTest("idea/testData/formatter/callChain/ContinuationIndentForChainedCalls.after.inv.kt");
             }
 
             @TestMetadata("FunctionLiteralsInChainCalls.after.inv.kt")
             public void testFunctionLiteralsInChainCalls() throws Exception {
-                runTest("testData/formatter/callChain/FunctionLiteralsInChainCalls.after.inv.kt");
+                runTest("idea/testData/formatter/callChain/FunctionLiteralsInChainCalls.after.inv.kt");
             }
 
             @TestMetadata("NotCallChain.after.inv.kt")
             public void testNotCallChain() throws Exception {
-                runTest("testData/formatter/callChain/NotCallChain.after.inv.kt");
+                runTest("idea/testData/formatter/callChain/NotCallChain.after.inv.kt");
             }
         }
 
-        @TestMetadata("testData/formatter/fileAnnotations")
+        @TestMetadata("idea/testData/formatter/fileAnnotations")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class FileAnnotations extends AbstractFormatterTest {
@@ -1913,11 +1943,11 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInFileAnnotations() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/fileAnnotations"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/fileAnnotations"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
             }
         }
 
-        @TestMetadata("testData/formatter/modifierList")
+        @TestMetadata("idea/testData/formatter/modifierList")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class ModifierList extends AbstractFormatterTest {
@@ -1926,11 +1956,11 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInModifierList() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/modifierList"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/modifierList"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
             }
         }
 
-        @TestMetadata("testData/formatter/parameterList")
+        @TestMetadata("idea/testData/formatter/parameterList")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class ParameterList extends AbstractFormatterTest {
@@ -1939,16 +1969,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInParameterList() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/parameterList"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/parameterList"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
             }
 
             @TestMetadata("DefaultParameterValues.after.inv.kt")
             public void testDefaultParameterValues() throws Exception {
-                runTest("testData/formatter/parameterList/DefaultParameterValues.after.inv.kt");
+                runTest("idea/testData/formatter/parameterList/DefaultParameterValues.after.inv.kt");
             }
         }
 
-        @TestMetadata("testData/formatter/trailingComma")
+        @TestMetadata("idea/testData/formatter/trailingComma")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class TrailingComma extends AbstractFormatterTest {
@@ -1957,10 +1987,10 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInTrailingComma() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
             }
 
-            @TestMetadata("testData/formatter/trailingComma/collectionLiteralExpression")
+            @TestMetadata("idea/testData/formatter/trailingComma/collectionLiteralExpression")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class CollectionLiteralExpression extends AbstractFormatterTest {
@@ -1969,16 +1999,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
                 }
 
                 public void testAllFilesPresentInCollectionLiteralExpression() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/collectionLiteralExpression"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/collectionLiteralExpression"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
                 }
 
                 @TestMetadata("CollectionLiteralInAnnotation.after.inv.kt")
                 public void testCollectionLiteralInAnnotation() throws Exception {
-                    runTest("testData/formatter/trailingComma/collectionLiteralExpression/CollectionLiteralInAnnotation.after.inv.kt");
+                    runTest("idea/testData/formatter/trailingComma/collectionLiteralExpression/CollectionLiteralInAnnotation.after.inv.kt");
                 }
             }
 
-            @TestMetadata("testData/formatter/trailingComma/destructuringDeclarations")
+            @TestMetadata("idea/testData/formatter/trailingComma/destructuringDeclarations")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class DestructuringDeclarations extends AbstractFormatterTest {
@@ -1987,21 +2017,21 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
                 }
 
                 public void testAllFilesPresentInDestructuringDeclarations() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/destructuringDeclarations"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/destructuringDeclarations"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
                 }
 
                 @TestMetadata("DestructuringDeclarationsInLambda.after.inv.kt")
                 public void testDestructuringDeclarationsInLambda() throws Exception {
-                    runTest("testData/formatter/trailingComma/destructuringDeclarations/DestructuringDeclarationsInLambda.after.inv.kt");
+                    runTest("idea/testData/formatter/trailingComma/destructuringDeclarations/DestructuringDeclarationsInLambda.after.inv.kt");
                 }
 
                 @TestMetadata("MultiVariableDeclaration.after.inv.kt")
                 public void testMultiVariableDeclaration() throws Exception {
-                    runTest("testData/formatter/trailingComma/destructuringDeclarations/MultiVariableDeclaration.after.inv.kt");
+                    runTest("idea/testData/formatter/trailingComma/destructuringDeclarations/MultiVariableDeclaration.after.inv.kt");
                 }
             }
 
-            @TestMetadata("testData/formatter/trailingComma/enumEntry")
+            @TestMetadata("idea/testData/formatter/trailingComma/enumEntry")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class EnumEntry extends AbstractFormatterTest {
@@ -2010,16 +2040,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
                 }
 
                 public void testAllFilesPresentInEnumEntry() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/enumEntry"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/enumEntry"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
                 }
 
                 @TestMetadata("Enum.after.inv.kt")
                 public void testEnum() throws Exception {
-                    runTest("testData/formatter/trailingComma/enumEntry/Enum.after.inv.kt");
+                    runTest("idea/testData/formatter/trailingComma/enumEntry/Enum.after.inv.kt");
                 }
             }
 
-            @TestMetadata("testData/formatter/trailingComma/indices")
+            @TestMetadata("idea/testData/formatter/trailingComma/indices")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class Indices extends AbstractFormatterTest {
@@ -2028,16 +2058,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
                 }
 
                 public void testAllFilesPresentInIndices() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/indices"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/indices"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
                 }
 
                 @TestMetadata("IndicesAccess.after.inv.kt")
                 public void testIndicesAccess() throws Exception {
-                    runTest("testData/formatter/trailingComma/indices/IndicesAccess.after.inv.kt");
+                    runTest("idea/testData/formatter/trailingComma/indices/IndicesAccess.after.inv.kt");
                 }
             }
 
-            @TestMetadata("testData/formatter/trailingComma/lambdaParameters")
+            @TestMetadata("idea/testData/formatter/trailingComma/lambdaParameters")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class LambdaParameters extends AbstractFormatterTest {
@@ -2046,16 +2076,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
                 }
 
                 public void testAllFilesPresentInLambdaParameters() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/lambdaParameters"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/lambdaParameters"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
                 }
 
                 @TestMetadata("LambdaParameterList.after.inv.kt")
                 public void testLambdaParameterList() throws Exception {
-                    runTest("testData/formatter/trailingComma/lambdaParameters/LambdaParameterList.after.inv.kt");
+                    runTest("idea/testData/formatter/trailingComma/lambdaParameters/LambdaParameterList.after.inv.kt");
                 }
             }
 
-            @TestMetadata("testData/formatter/trailingComma/typeArguments")
+            @TestMetadata("idea/testData/formatter/trailingComma/typeArguments")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class TypeArguments extends AbstractFormatterTest {
@@ -2064,16 +2094,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
                 }
 
                 public void testAllFilesPresentInTypeArguments() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/typeArguments"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/typeArguments"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
                 }
 
                 @TestMetadata("TypeArgumentList.after.inv.kt")
                 public void testTypeArgumentList() throws Exception {
-                    runTest("testData/formatter/trailingComma/typeArguments/TypeArgumentList.after.inv.kt");
+                    runTest("idea/testData/formatter/trailingComma/typeArguments/TypeArgumentList.after.inv.kt");
                 }
             }
 
-            @TestMetadata("testData/formatter/trailingComma/typeParameters")
+            @TestMetadata("idea/testData/formatter/trailingComma/typeParameters")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class TypeParameters extends AbstractFormatterTest {
@@ -2082,16 +2112,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
                 }
 
                 public void testAllFilesPresentInTypeParameters() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/typeParameters"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/typeParameters"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
                 }
 
                 @TestMetadata("TypeParameterList.after.inv.kt")
                 public void testTypeParameterList() throws Exception {
-                    runTest("testData/formatter/trailingComma/typeParameters/TypeParameterList.after.inv.kt");
+                    runTest("idea/testData/formatter/trailingComma/typeParameters/TypeParameterList.after.inv.kt");
                 }
             }
 
-            @TestMetadata("testData/formatter/trailingComma/valueArguments")
+            @TestMetadata("idea/testData/formatter/trailingComma/valueArguments")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class ValueArguments extends AbstractFormatterTest {
@@ -2100,31 +2130,31 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
                 }
 
                 public void testAllFilesPresentInValueArguments() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/valueArguments"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/valueArguments"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
                 }
 
                 @TestMetadata("ArgumentListChopAsNeeded.after.inv.kt")
                 public void testArgumentListChopAsNeeded() throws Exception {
-                    runTest("testData/formatter/trailingComma/valueArguments/ArgumentListChopAsNeeded.after.inv.kt");
+                    runTest("idea/testData/formatter/trailingComma/valueArguments/ArgumentListChopAsNeeded.after.inv.kt");
                 }
 
                 @TestMetadata("ArgumentListDoNotWrap.after.inv.kt")
                 public void testArgumentListDoNotWrap() throws Exception {
-                    runTest("testData/formatter/trailingComma/valueArguments/ArgumentListDoNotWrap.after.inv.kt");
+                    runTest("idea/testData/formatter/trailingComma/valueArguments/ArgumentListDoNotWrap.after.inv.kt");
                 }
 
                 @TestMetadata("ArgumentListWrapAlways.after.inv.kt")
                 public void testArgumentListWrapAlways() throws Exception {
-                    runTest("testData/formatter/trailingComma/valueArguments/ArgumentListWrapAlways.after.inv.kt");
+                    runTest("idea/testData/formatter/trailingComma/valueArguments/ArgumentListWrapAlways.after.inv.kt");
                 }
 
                 @TestMetadata("ArgumentListWrapAsNeeded.after.inv.kt")
                 public void testArgumentListWrapAsNeeded() throws Exception {
-                    runTest("testData/formatter/trailingComma/valueArguments/ArgumentListWrapAsNeeded.after.inv.kt");
+                    runTest("idea/testData/formatter/trailingComma/valueArguments/ArgumentListWrapAsNeeded.after.inv.kt");
                 }
             }
 
-            @TestMetadata("testData/formatter/trailingComma/valueParameters")
+            @TestMetadata("idea/testData/formatter/trailingComma/valueParameters")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class ValueParameters extends AbstractFormatterTest {
@@ -2133,36 +2163,36 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
                 }
 
                 public void testAllFilesPresentInValueParameters() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/valueParameters"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/valueParameters"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
                 }
 
                 @TestMetadata("LambdaValueParameters.after.inv.kt")
                 public void testLambdaValueParameters() throws Exception {
-                    runTest("testData/formatter/trailingComma/valueParameters/LambdaValueParameters.after.inv.kt");
+                    runTest("idea/testData/formatter/trailingComma/valueParameters/LambdaValueParameters.after.inv.kt");
                 }
 
                 @TestMetadata("ParameterListChopAsNeeded.after.inv.kt")
                 public void testParameterListChopAsNeeded() throws Exception {
-                    runTest("testData/formatter/trailingComma/valueParameters/ParameterListChopAsNeeded.after.inv.kt");
+                    runTest("idea/testData/formatter/trailingComma/valueParameters/ParameterListChopAsNeeded.after.inv.kt");
                 }
 
                 @TestMetadata("ParameterListDoNotWrap.after.inv.kt")
                 public void testParameterListDoNotWrap() throws Exception {
-                    runTest("testData/formatter/trailingComma/valueParameters/ParameterListDoNotWrap.after.inv.kt");
+                    runTest("idea/testData/formatter/trailingComma/valueParameters/ParameterListDoNotWrap.after.inv.kt");
                 }
 
                 @TestMetadata("ParameterListWrapAlways.after.inv.kt")
                 public void testParameterListWrapAlways() throws Exception {
-                    runTest("testData/formatter/trailingComma/valueParameters/ParameterListWrapAlways.after.inv.kt");
+                    runTest("idea/testData/formatter/trailingComma/valueParameters/ParameterListWrapAlways.after.inv.kt");
                 }
 
                 @TestMetadata("ParameterListWrapAsNeeded.after.inv.kt")
                 public void testParameterListWrapAsNeeded() throws Exception {
-                    runTest("testData/formatter/trailingComma/valueParameters/ParameterListWrapAsNeeded.after.inv.kt");
+                    runTest("idea/testData/formatter/trailingComma/valueParameters/ParameterListWrapAsNeeded.after.inv.kt");
                 }
             }
 
-            @TestMetadata("testData/formatter/trailingComma/whenEntry")
+            @TestMetadata("idea/testData/formatter/trailingComma/whenEntry")
             @TestDataPath("$PROJECT_ROOT")
             @RunWith(JUnit3RunnerWithInners.class)
             public static class WhenEntry extends AbstractFormatterTest {
@@ -2171,18 +2201,18 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
                 }
 
                 public void testAllFilesPresentInWhenEntry() throws Exception {
-                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/whenEntry"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
+                    KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/whenEntry"), Pattern.compile("^([^\\.]+)\\.after\\.inv\\.kt.*$"), null, true);
                 }
 
                 @TestMetadata("WhenEntry.after.inv.kt")
                 public void testWhenEntry() throws Exception {
-                    runTest("testData/formatter/trailingComma/whenEntry/WhenEntry.after.inv.kt");
+                    runTest("idea/testData/formatter/trailingComma/whenEntry/WhenEntry.after.inv.kt");
                 }
             }
         }
     }
 
-    @TestMetadata("testData/formatter/trailingComma")
+    @TestMetadata("idea/testData/formatter/trailingComma")
     @TestDataPath("$PROJECT_ROOT")
     @RunWith(JUnit3RunnerWithInners.class)
     public static class FormatterInvertedCallSite extends AbstractFormatterTest {
@@ -2191,10 +2221,10 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
         }
 
         public void testAllFilesPresentInFormatterInvertedCallSite() throws Exception {
-            KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true);
+            KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true);
         }
 
-        @TestMetadata("testData/formatter/trailingComma/collectionLiteralExpression")
+        @TestMetadata("idea/testData/formatter/trailingComma/collectionLiteralExpression")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class CollectionLiteralExpression extends AbstractFormatterTest {
@@ -2203,16 +2233,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInCollectionLiteralExpression() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/collectionLiteralExpression"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/collectionLiteralExpression"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true);
             }
 
             @TestMetadata("CollectionLiteralInAnnotation.call.after.inv.kt")
             public void testCollectionLiteralInAnnotation() throws Exception {
-                runTest("testData/formatter/trailingComma/collectionLiteralExpression/CollectionLiteralInAnnotation.call.after.inv.kt");
+                runTest("idea/testData/formatter/trailingComma/collectionLiteralExpression/CollectionLiteralInAnnotation.call.after.inv.kt");
             }
         }
 
-        @TestMetadata("testData/formatter/trailingComma/destructuringDeclarations")
+        @TestMetadata("idea/testData/formatter/trailingComma/destructuringDeclarations")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class DestructuringDeclarations extends AbstractFormatterTest {
@@ -2221,11 +2251,11 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInDestructuringDeclarations() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/destructuringDeclarations"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/destructuringDeclarations"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true);
             }
         }
 
-        @TestMetadata("testData/formatter/trailingComma/enumEntry")
+        @TestMetadata("idea/testData/formatter/trailingComma/enumEntry")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class EnumEntry extends AbstractFormatterTest {
@@ -2234,11 +2264,11 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInEnumEntry() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/enumEntry"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/enumEntry"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true);
             }
         }
 
-        @TestMetadata("testData/formatter/trailingComma/indices")
+        @TestMetadata("idea/testData/formatter/trailingComma/indices")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class Indices extends AbstractFormatterTest {
@@ -2247,16 +2277,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInIndices() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/indices"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/indices"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true);
             }
 
             @TestMetadata("IndicesAccess.call.after.inv.kt")
             public void testIndicesAccess() throws Exception {
-                runTest("testData/formatter/trailingComma/indices/IndicesAccess.call.after.inv.kt");
+                runTest("idea/testData/formatter/trailingComma/indices/IndicesAccess.call.after.inv.kt");
             }
         }
 
-        @TestMetadata("testData/formatter/trailingComma/lambdaParameters")
+        @TestMetadata("idea/testData/formatter/trailingComma/lambdaParameters")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class LambdaParameters extends AbstractFormatterTest {
@@ -2265,16 +2295,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInLambdaParameters() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/lambdaParameters"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/lambdaParameters"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true);
             }
 
             @TestMetadata("LambdaParameterList.call.after.inv.kt")
             public void testLambdaParameterList() throws Exception {
-                runTest("testData/formatter/trailingComma/lambdaParameters/LambdaParameterList.call.after.inv.kt");
+                runTest("idea/testData/formatter/trailingComma/lambdaParameters/LambdaParameterList.call.after.inv.kt");
             }
         }
 
-        @TestMetadata("testData/formatter/trailingComma/typeArguments")
+        @TestMetadata("idea/testData/formatter/trailingComma/typeArguments")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class TypeArguments extends AbstractFormatterTest {
@@ -2283,16 +2313,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInTypeArguments() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/typeArguments"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/typeArguments"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true);
             }
 
             @TestMetadata("TypeArgumentList.call.after.inv.kt")
             public void testTypeArgumentList() throws Exception {
-                runTest("testData/formatter/trailingComma/typeArguments/TypeArgumentList.call.after.inv.kt");
+                runTest("idea/testData/formatter/trailingComma/typeArguments/TypeArgumentList.call.after.inv.kt");
             }
         }
 
-        @TestMetadata("testData/formatter/trailingComma/typeParameters")
+        @TestMetadata("idea/testData/formatter/trailingComma/typeParameters")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class TypeParameters extends AbstractFormatterTest {
@@ -2301,16 +2331,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInTypeParameters() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/typeParameters"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/typeParameters"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true);
             }
 
             @TestMetadata("TypeParameterList.call.after.inv.kt")
             public void testTypeParameterList() throws Exception {
-                runTest("testData/formatter/trailingComma/typeParameters/TypeParameterList.call.after.inv.kt");
+                runTest("idea/testData/formatter/trailingComma/typeParameters/TypeParameterList.call.after.inv.kt");
             }
         }
 
-        @TestMetadata("testData/formatter/trailingComma/valueArguments")
+        @TestMetadata("idea/testData/formatter/trailingComma/valueArguments")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class ValueArguments extends AbstractFormatterTest {
@@ -2319,16 +2349,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInValueArguments() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/valueArguments"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/valueArguments"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true);
             }
 
             @TestMetadata("ArgumentListWrapAsNeeded.call.after.inv.kt")
             public void testArgumentListWrapAsNeeded() throws Exception {
-                runTest("testData/formatter/trailingComma/valueArguments/ArgumentListWrapAsNeeded.call.after.inv.kt");
+                runTest("idea/testData/formatter/trailingComma/valueArguments/ArgumentListWrapAsNeeded.call.after.inv.kt");
             }
         }
 
-        @TestMetadata("testData/formatter/trailingComma/valueParameters")
+        @TestMetadata("idea/testData/formatter/trailingComma/valueParameters")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class ValueParameters extends AbstractFormatterTest {
@@ -2337,16 +2367,16 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInValueParameters() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/valueParameters"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/valueParameters"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true);
             }
 
             @TestMetadata("ParameterListWrapAsNeeded.call.after.inv.kt")
             public void testParameterListWrapAsNeeded() throws Exception {
-                runTest("testData/formatter/trailingComma/valueParameters/ParameterListWrapAsNeeded.call.after.inv.kt");
+                runTest("idea/testData/formatter/trailingComma/valueParameters/ParameterListWrapAsNeeded.call.after.inv.kt");
             }
         }
 
-        @TestMetadata("testData/formatter/trailingComma/whenEntry")
+        @TestMetadata("idea/testData/formatter/trailingComma/whenEntry")
         @TestDataPath("$PROJECT_ROOT")
         @RunWith(JUnit3RunnerWithInners.class)
         public static class WhenEntry extends AbstractFormatterTest {
@@ -2355,7 +2385,7 @@ public class FormatterTestGenerated extends AbstractFormatterTest {
             }
 
             public void testAllFilesPresentInWhenEntry() throws Exception {
-                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("testData/formatter/trailingComma/whenEntry"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true);
+                KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("idea/testData/formatter/trailingComma/whenEntry"), Pattern.compile("^([^\\.]+)\\.call\\.after\\.inv\\.kt.*$"), null, true);
             }
         }
     }
diff --git a/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry.after.kt b/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry.after.kt
new file mode 100644
index 000000000000..b6e8784754f4
--- /dev/null
+++ b/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry.after.kt
@@ -0,0 +1,8 @@
+fun test() {
+    val message1 = "${
+        "sd"
+    }"
+    val message2 = {
+        "sd"
+    }()
+}
\ No newline at end of file
diff --git a/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry.kt b/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry.kt
new file mode 100644
index 000000000000..9e6da5971791
--- /dev/null
+++ b/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry.kt
@@ -0,0 +1,8 @@
+fun test() {
+    val message1 = "${
+    "sd"
+    }"
+    val message2 = {
+    "sd"
+    }()
+}
\ No newline at end of file
diff --git a/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry2.after.kt b/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry2.after.kt
new file mode 100644
index 000000000000..d84b49ea8b86
--- /dev/null
+++ b/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry2.after.kt
@@ -0,0 +1,4 @@
+fun test() {
+    val message1 = "${"sd"}"
+    val message2 = { "sd" }()
+}
\ No newline at end of file
diff --git a/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry2.kt b/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry2.kt
new file mode 100644
index 000000000000..50e7336b67a1
--- /dev/null
+++ b/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry2.kt
@@ -0,0 +1,4 @@
+fun test() {
+    val message1 = "${"sd"}"
+    val message2 = {"sd"}()
+}
\ No newline at end of file
diff --git a/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry3.after.kt b/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry3.after.kt
new file mode 100644
index 000000000000..c516de2d28a1
--- /dev/null
+++ b/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry3.after.kt
@@ -0,0 +1,3 @@
+val message = "${
+    "sd"
+}"
\ No newline at end of file
diff --git a/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry3.kt b/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry3.kt
new file mode 100644
index 000000000000..740d2762b0f4
--- /dev/null
+++ b/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry3.kt
@@ -0,0 +1,2 @@
+val message = "${"sd"
+}"
\ No newline at end of file
diff --git a/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry4.after.kt b/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry4.after.kt
new file mode 100644
index 000000000000..e99df0cf0b03
--- /dev/null
+++ b/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry4.after.kt
@@ -0,0 +1,5 @@
+fun test() {
+    val message = "start ${
+        "sd"
+    } end"
+}
\ No newline at end of file
diff --git a/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry4.kt b/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry4.kt
new file mode 100644
index 000000000000..c12767396767
--- /dev/null
+++ b/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry4.kt
@@ -0,0 +1,4 @@
+fun test() {
+    val message = "start ${
+    "sd"} end"
+}
\ No newline at end of file
diff --git a/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry5.after.kt b/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry5.after.kt
new file mode 100644
index 000000000000..912fa8acd42c
--- /dev/null
+++ b/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry5.after.kt
@@ -0,0 +1,5 @@
+fun test() {
+    "start ${
+        println("sd")
+    } end"
+}
\ No newline at end of file
diff --git a/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry5.kt b/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry5.kt
new file mode 100644
index 000000000000..db6377fafcdb
--- /dev/null
+++ b/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry5.kt
@@ -0,0 +1,4 @@
+fun test() {
+    "start ${
+    println("sd")} end"
+}
\ No newline at end of file
diff --git a/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry6.after.kt b/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry6.after.kt
new file mode 100644
index 000000000000..450d05f14fcd
--- /dev/null
+++ b/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry6.after.kt
@@ -0,0 +1,7 @@
+fun test() {
+    "start ${
+        println(
+                "sd"
+        )
+    } end"
+}
\ No newline at end of file
diff --git a/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry6.kt b/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry6.kt
new file mode 100644
index 000000000000..1eeef156fd6e
--- /dev/null
+++ b/plugins/kotlin/idea/tests/testData/formatter/MultilineStringEntry6.kt
@@ -0,0 +1,5 @@
+fun test() {
+    "start ${println(
+        "sd"
+    )} end"
+}
\ No newline at end of file
diff --git a/plugins/kotlin/idea/tests/testData/intentions/toOrdinaryStringLiteral/lineBreakInExpression.kt.after b/plugins/kotlin/idea/tests/testData/intentions/toOrdinaryStringLiteral/lineBreakInExpression.kt.after
index b71a9dc9c96e..2e9f263a980e 100644
--- a/plugins/kotlin/idea/tests/testData/intentions/toOrdinaryStringLiteral/lineBreakInExpression.kt.after
+++ b/plugins/kotlin/idea/tests/testData/intentions/toOrdinaryStringLiteral/lineBreakInExpression.kt.after
@@ -1,2 +1,4 @@
-val v = "${2 +
-        2}"
\ No newline at end of file
+val v = "${
+    2 +
+            2
+}"
\ No newline at end of file
diff --git a/plugins/kotlin/idea/tests/testData/refactoring/inline/inlineVariableOrProperty/stringTemplates/rawToNonRaw.kt.after b/plugins/kotlin/idea/tests/testData/refactoring/inline/inlineVariableOrProperty/stringTemplates/rawToNonRaw.kt.after
index e20ba0da3006..8d6cea690bc6 100644
--- a/plugins/kotlin/idea/tests/testData/refactoring/inline/inlineVariableOrProperty/stringTemplates/rawToNonRaw.kt.after
+++ b/plugins/kotlin/idea/tests/testData/refactoring/inline/inlineVariableOrProperty/stringTemplates/rawToNonRaw.kt.after
@@ -1,4 +1,6 @@
 fun foo() {
-    val y = "x=${"""ab
-    c"""}"
+    val y = "x=${
+        """ab
+        c"""
+    }"
 }
\ No newline at end of file