From 6556acabbab52ff458566db8faed83c8dcd9c9f0 Mon Sep 17 00:00:00 2001 From: Alexander Korepanov Date: Tue, 19 Dec 2023 16:15:00 +0100 Subject: [PATCH] [JS FIR] Enable FIR JS stepping tests ^KT-64422 Fixed --- .../debug/stepping/IfTrueThenFalse.kt | 3 + compiler/testData/debug/stepping/dataClass.kt | 59 +- compiler/testData/debug/stepping/if.kt | 5 +- .../debug/stepping/ifThenElseFalse.kt | 6 + .../debug/stepping/ifWithInlineInCondition.kt | 4 + .../testData/debug/stepping/whenIsChecks.kt | 15 + .../generators/tests/GenerateJsTests.kt | 7 +- .../kotlin/js/test/fir/AbstractJsFirTest.kt | 30 +- .../test/fir/FirJsSteppingTestGenerated.java | 687 ++++++++++++++++++ 9 files changed, 800 insertions(+), 16 deletions(-) create mode 100644 js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/fir/FirJsSteppingTestGenerated.java diff --git a/compiler/testData/debug/stepping/IfTrueThenFalse.kt b/compiler/testData/debug/stepping/IfTrueThenFalse.kt index 2825bb653d9..a9d944cfbf4 100644 --- a/compiler/testData/debug/stepping/IfTrueThenFalse.kt +++ b/compiler/testData/debug/stepping/IfTrueThenFalse.kt @@ -19,6 +19,9 @@ fun box() { // EXPECTATIONS JS_IR // test.kt:6 box // test.kt:3 cond +// EXPECTATIONS FIR JS_IR +// test.kt:9 box +// EXPECTATIONS JS_IR // test.kt:10 box // EXPECTATIONS WASM diff --git a/compiler/testData/debug/stepping/dataClass.kt b/compiler/testData/debug/stepping/dataClass.kt index 861710bd054..7a4586fc0e1 100644 --- a/compiler/testData/debug/stepping/dataClass.kt +++ b/compiler/testData/debug/stepping/dataClass.kt @@ -61,7 +61,7 @@ fun box() { // test.kt:25 box // test.kt:26 box -// EXPECTATIONS JS_IR +// EXPECTATIONS ClassicFrontend JS_IR // test.kt:14 box // test.kt:4 // test.kt:4 @@ -118,6 +118,63 @@ fun box() { // test.kt:6 // test.kt:26 box +// EXPECTATIONS FIR JS_IR // TODO: There is an inconsistency in names between K1 and K2. This should be fixed in KT-64435. +// test.kt:14 box +// test.kt:4 +// test.kt:4 +// test.kt:4 +// test.kt:15 box +// test.kt:4 +// test.kt:4 +// test.kt:4 +// test.kt:15 box +// test.kt:1 protoOf.equals +// test.kt:1 protoOf.equals +// test.kt:1 protoOf.equals +// test.kt:1 protoOf.equals +// test.kt:1 protoOf.equals +// test.kt:1 protoOf.equals +// test.kt:16 box +// test.kt:1 protoOf.hashCode +// test.kt:1 protoOf.hashCode +// test.kt:17 box +// test.kt:1 protoOf.toString +// test.kt:18 box +// test.kt:1 protoOf.component1_7eebsc_k$ +// test.kt:18 box +// test.kt:1 protoOf.component2_7eebsb_k$ +// test.kt:19 box +// test.kt:1 protoOf.copy$default_8mg6yi_k$ +// test.kt:1 protoOf.copy$default_8mg6yi_k$ +// test.kt:1 protoOf.copy_xhhsuv_k$ +// test.kt:4 +// test.kt:4 +// test.kt:4 +// test.kt:20 box +// test.kt:6 +// test.kt:6 +// test.kt:6 +// test.kt:21 box +// test.kt:6 +// test.kt:6 +// test.kt:6 +// test.kt:21 box +// test.kt:8 equals +// test.kt:22 box +// test.kt:9 hashCode +// test.kt:23 box +// test.kt:7 toString +// test.kt:24 box +// test.kt:1 protoOf.component1_7eebsc_k$ +// test.kt:24 box +// test.kt:1 protoOf.component2_7eebsb_k$ +// test.kt:25 box +// test.kt:10 copy +// test.kt:6 +// test.kt:6 +// test.kt:6 +// test.kt:26 box + // EXPECTATIONS WASM // test.kt:14 $box (12, 14, 18, 18, 18, 18, 12) // String.kt:141 $kotlin.stringLiteral (17, 28, 17, 17, 28, 17, 17, 28, 17, 17, 28, 17, 17, 28, 17, 17, 28, 17, 17, 28, 17, 17, 28, 17, 17, 28, 17, 17, 28, 17, 17, 28, 17, 17, 28, 17, 17, 28, 17) diff --git a/compiler/testData/debug/stepping/if.kt b/compiler/testData/debug/stepping/if.kt index 48ff51e1152..6b0533a29f2 100644 --- a/compiler/testData/debug/stepping/if.kt +++ b/compiler/testData/debug/stepping/if.kt @@ -25,8 +25,11 @@ inline fun getB(): Int { // test.kt:15 box // test.kt:9 box -// EXPECTATIONS JS_IR +// EXPECTATIONS ClassicFrontend JS_IR // test.kt:5 box +// EXPECTATIONS FIR JS_IR +// test.kt:6 box +// EXPECTATIONS JS_IR // test.kt:12 getA // test.kt:9 box diff --git a/compiler/testData/debug/stepping/ifThenElseFalse.kt b/compiler/testData/debug/stepping/ifThenElseFalse.kt index a746b23c5fa..929c725a143 100644 --- a/compiler/testData/debug/stepping/ifThenElseFalse.kt +++ b/compiler/testData/debug/stepping/ifThenElseFalse.kt @@ -40,6 +40,9 @@ fun box() { // test.kt:16 box // test.kt:9 foo // test.kt:6 cond +// EXPECTATIONS FIR JS_IR +// test.kt:12 foo +// EXPECTATIONS JS_IR // test.kt:13 foo // test.kt:17 box // test.kt:18 box @@ -47,6 +50,9 @@ fun box() { // test.kt:6 cond // test.kt:10 foo // test.kt:6 cond +// EXPECTATIONS FIR JS_IR +// test.kt:12 foo +// EXPECTATIONS JS_IR // test.kt:13 foo // test.kt:19 box diff --git a/compiler/testData/debug/stepping/ifWithInlineInCondition.kt b/compiler/testData/debug/stepping/ifWithInlineInCondition.kt index ffaa4bfb820..bb39d714353 100644 --- a/compiler/testData/debug/stepping/ifWithInlineInCondition.kt +++ b/compiler/testData/debug/stepping/ifWithInlineInCondition.kt @@ -60,7 +60,11 @@ fun nop() {} // test.kt:5 box // test.kt:31 nop // test.kt:25 box +// EXPECTATIONS FIR JS_IR +// test.kt:9 box +// EXPECTATIONS ClassicFrontend JS_IR // test.kt:8 box +// EXPECTATIONS JS_IR // test.kt:12 box // test.kt:31 nop // test.kt:20 box diff --git a/compiler/testData/debug/stepping/whenIsChecks.kt b/compiler/testData/debug/stepping/whenIsChecks.kt index 553102ff89c..9cfe6857ee9 100644 --- a/compiler/testData/debug/stepping/whenIsChecks.kt +++ b/compiler/testData/debug/stepping/whenIsChecks.kt @@ -40,10 +40,25 @@ fun box() { // EXPECTATIONS JS_IR // test.kt:16 box +// EXPECTATIONS FIR JS_IR +// test.kt:6 foo +// test.kt:7 foo +// test.kt:9 foo +// EXPECTATIONS JS_IR // test.kt:13 foo // test.kt:17 box +// EXPECTATIONS FIR JS_IR +// test.kt:6 foo +// test.kt:7 foo +// test.kt:9 foo +// EXPECTATIONS JS_IR // test.kt:13 foo // test.kt:18 box +// EXPECTATIONS FIR JS_IR +// test.kt:6 foo +// test.kt:7 foo +// test.kt:9 foo +// EXPECTATIONS JS_IR // test.kt:13 foo // test.kt:19 box diff --git a/js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateJsTests.kt b/js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateJsTests.kt index 3c5974c06e7..2800661f32f 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateJsTests.kt +++ b/js/js.tests/test/org/jetbrains/kotlin/generators/tests/GenerateJsTests.kt @@ -298,10 +298,9 @@ fun main(args: Array) { model("codegen/boxWasmJsInterop") } - // see todo on AbstractFirJsSteppingTest -// testClass { -// model("debug/stepping") -// } + testClass { + model("debug/stepping") + } testClass { model("loadJava/compiledKotlin", extension = "kt") diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/fir/AbstractJsFirTest.kt b/js/js.tests/test/org/jetbrains/kotlin/js/test/fir/AbstractJsFirTest.kt index f3574bce6cd..3c1e40cb8e9 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/fir/AbstractJsFirTest.kt +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/fir/AbstractJsFirTest.kt @@ -1,9 +1,11 @@ package org.jetbrains.kotlin.js.test.fir +import org.jetbrains.kotlin.js.test.JsSteppingTestAdditionalSourceProvider import org.jetbrains.kotlin.js.test.ir.AbstractJsBlackBoxCodegenTestBase import org.jetbrains.kotlin.js.test.converters.FirJsKlibBackendFacade import org.jetbrains.kotlin.js.test.converters.JsIrBackendFacade import org.jetbrains.kotlin.js.test.converters.incremental.RecompileModuleJsIrBackendFacade +import org.jetbrains.kotlin.js.test.handlers.JsDebugRunner import org.jetbrains.kotlin.js.test.handlers.JsIrRecompiledArtifactsIdentityHandler import org.jetbrains.kotlin.parsing.parseBoolean import org.jetbrains.kotlin.test.Constructor @@ -23,6 +25,7 @@ import org.jetbrains.kotlin.test.frontend.fir.handlers.* import org.jetbrains.kotlin.test.model.* import org.jetbrains.kotlin.test.runners.codegen.commonFirHandlersForCodegenTest import org.jetbrains.kotlin.test.services.configuration.JsEnvironmentConfigurator +import org.jetbrains.kotlin.utils.bind import java.lang.Boolean.getBoolean @@ -142,16 +145,23 @@ open class AbstractFirJsCodegenInlineTest : AbstractFirJsTest( // } //} -// TODO: implement separate expectations for FIR/JS to reuse testdata, disabled for now -//open class AbstractFirJsSteppingTest : AbstractFirJsTest( -// pathToTestDir = "compiler/testData/debug/stepping/", -// testGroupOutputDirPrefix = "debug/stepping/" -//) { -// override fun TestConfigurationBuilder.configuration() { -// commonConfigurationForJsBlackBoxCodegenTest() -// configurationForIrJsSteppingTest() -// } -//} +open class AbstractFirJsSteppingTest : AbstractFirJsTest( + pathToTestDir = "compiler/testData/debug/stepping/", + testGroupOutputDirPrefix = "debug/stepping/" +) { + override fun TestConfigurationBuilder.configuration() { + commonConfigurationForJsBlackBoxCodegenTest() + defaultDirectives { + +JsEnvironmentConfigurationDirectives.NO_COMMON_FILES + } + useAdditionalSourceProviders(::JsSteppingTestAdditionalSourceProvider) + jsArtifactsHandlersStep { + useHandlers( + ::JsDebugRunner.bind(false) + ) + } + } +} open class AbstractFirJsCodegenWasmJsInteropTest : AbstractFirJsTest( pathToTestDir = "compiler/testData/codegen/wasmJsInterop", diff --git a/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/fir/FirJsSteppingTestGenerated.java b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/fir/FirJsSteppingTestGenerated.java new file mode 100644 index 00000000000..57b79499cec --- /dev/null +++ b/js/js.tests/tests-gen/org/jetbrains/kotlin/js/test/fir/FirJsSteppingTestGenerated.java @@ -0,0 +1,687 @@ +/* + * Copyright 2010-2024 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.js.test.fir; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.TargetBackend; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.GenerateJsTestsKt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("compiler/testData/debug/stepping") +@TestDataPath("$PROJECT_ROOT") +public class FirJsSteppingTestGenerated extends AbstractFirJsSteppingTest { + @Test + public void testAllFilesPresentInStepping() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/debug/stepping"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JS_IR, true); + } + + @Test + @TestMetadata("anonymousFunction.kt") + public void testAnonymousFunction() throws Exception { + runTest("compiler/testData/debug/stepping/anonymousFunction.kt"); + } + + @Test + @TestMetadata("anonymousFunctionDirect.kt") + public void testAnonymousFunctionDirect() throws Exception { + runTest("compiler/testData/debug/stepping/anonymousFunctionDirect.kt"); + } + + @Test + @TestMetadata("assertion.kt") + public void testAssertion() throws Exception { + runTest("compiler/testData/debug/stepping/assertion.kt"); + } + + @Test + @TestMetadata("beforeGotoToWhileStart.kt") + public void testBeforeGotoToWhileStart() throws Exception { + runTest("compiler/testData/debug/stepping/beforeGotoToWhileStart.kt"); + } + + @Test + @TestMetadata("callWithCallInArguments.kt") + public void testCallWithCallInArguments() throws Exception { + runTest("compiler/testData/debug/stepping/callWithCallInArguments.kt"); + } + + @Test + @TestMetadata("callWithReceiver.kt") + public void testCallWithReceiver() throws Exception { + runTest("compiler/testData/debug/stepping/callWithReceiver.kt"); + } + + @Test + @TestMetadata("callableReference.kt") + public void testCallableReference() throws Exception { + runTest("compiler/testData/debug/stepping/callableReference.kt"); + } + + @Test + @TestMetadata("chainCall.kt") + public void testChainCall() throws Exception { + runTest("compiler/testData/debug/stepping/chainCall.kt"); + } + + @Test + @TestMetadata("class.kt") + public void testClass() throws Exception { + runTest("compiler/testData/debug/stepping/class.kt"); + } + + @Test + @TestMetadata("classObject.kt") + public void testClassObject() throws Exception { + runTest("compiler/testData/debug/stepping/classObject.kt"); + } + + @Test + @TestMetadata("commentBeforeClass.kt") + public void testCommentBeforeClass() throws Exception { + runTest("compiler/testData/debug/stepping/commentBeforeClass.kt"); + } + + @Test + @TestMetadata("commentBeforeCompanionProperty.kt") + public void testCommentBeforeCompanionProperty() throws Exception { + runTest("compiler/testData/debug/stepping/commentBeforeCompanionProperty.kt"); + } + + @Test + @TestMetadata("commentBeforeFunctionWithDefault.kt") + public void testCommentBeforeFunctionWithDefault() throws Exception { + runTest("compiler/testData/debug/stepping/commentBeforeFunctionWithDefault.kt"); + } + + @Test + @TestMetadata("comments.kt") + public void testComments() throws Exception { + runTest("compiler/testData/debug/stepping/comments.kt"); + } + + @Test + @TestMetadata("compileTimeConstant.kt") + public void testCompileTimeConstant() throws Exception { + runTest("compiler/testData/debug/stepping/compileTimeConstant.kt"); + } + + @Test + @TestMetadata("conjunction.kt") + public void testConjunction() throws Exception { + runTest("compiler/testData/debug/stepping/conjunction.kt"); + } + + @Test + @TestMetadata("constantConditions.kt") + public void testConstantConditions() throws Exception { + runTest("compiler/testData/debug/stepping/constantConditions.kt"); + } + + @Test + @TestMetadata("constructorCall.kt") + public void testConstructorCall() throws Exception { + runTest("compiler/testData/debug/stepping/constructorCall.kt"); + } + + @Test + @TestMetadata("constructors.kt") + public void testConstructors() throws Exception { + runTest("compiler/testData/debug/stepping/constructors.kt"); + } + + @Test + @TestMetadata("continue.kt") + public void testContinue() throws Exception { + runTest("compiler/testData/debug/stepping/continue.kt"); + } + + @Test + @TestMetadata("dataClass.kt") + public void testDataClass() throws Exception { + runTest("compiler/testData/debug/stepping/dataClass.kt"); + } + + @Test + @TestMetadata("defaultParameter.kt") + public void testDefaultParameter() throws Exception { + runTest("compiler/testData/debug/stepping/defaultParameter.kt"); + } + + @Test + @TestMetadata("delegation.kt") + public void testDelegation() throws Exception { + runTest("compiler/testData/debug/stepping/delegation.kt"); + } + + @Test + @TestMetadata("enum.kt") + public void testEnum() throws Exception { + runTest("compiler/testData/debug/stepping/enum.kt"); + } + + @Test + @TestMetadata("for.kt") + public void testFor() throws Exception { + runTest("compiler/testData/debug/stepping/for.kt"); + } + + @Test + @TestMetadata("functionCallWithDefault.kt") + public void testFunctionCallWithDefault() throws Exception { + runTest("compiler/testData/debug/stepping/functionCallWithDefault.kt"); + } + + @Test + @TestMetadata("functionCallWithInlinedLambdaParam.kt") + public void testFunctionCallWithInlinedLambdaParam() throws Exception { + runTest("compiler/testData/debug/stepping/functionCallWithInlinedLambdaParam.kt"); + } + + @Test + @TestMetadata("functionCallWithLambdaParam.kt") + public void testFunctionCallWithLambdaParam() throws Exception { + runTest("compiler/testData/debug/stepping/functionCallWithLambdaParam.kt"); + } + + @Test + @TestMetadata("functionInAnotherFile.kt") + public void testFunctionInAnotherFile() throws Exception { + runTest("compiler/testData/debug/stepping/functionInAnotherFile.kt"); + } + + @Test + @TestMetadata("if.kt") + public void testIf() throws Exception { + runTest("compiler/testData/debug/stepping/if.kt"); + } + + @Test + @TestMetadata("if2.kt") + public void testIf2() throws Exception { + runTest("compiler/testData/debug/stepping/if2.kt"); + } + + @Test + @TestMetadata("ifThen.kt") + public void testIfThen() throws Exception { + runTest("compiler/testData/debug/stepping/ifThen.kt"); + } + + @Test + @TestMetadata("ifThenElse.kt") + public void testIfThenElse() throws Exception { + runTest("compiler/testData/debug/stepping/ifThenElse.kt"); + } + + @Test + @TestMetadata("ifThenElseFalse.kt") + public void testIfThenElseFalse() throws Exception { + runTest("compiler/testData/debug/stepping/ifThenElseFalse.kt"); + } + + @Test + @TestMetadata("IfTrueThenFalse.kt") + public void testIfTrueThenFalse() throws Exception { + runTest("compiler/testData/debug/stepping/IfTrueThenFalse.kt"); + } + + @Test + @TestMetadata("ifWithInlineInCondition.kt") + public void testIfWithInlineInCondition() throws Exception { + runTest("compiler/testData/debug/stepping/ifWithInlineInCondition.kt"); + } + + @Test + @TestMetadata("iincStepping.kt") + public void testIincStepping() throws Exception { + runTest("compiler/testData/debug/stepping/iincStepping.kt"); + } + + @Test + @TestMetadata("implicitThis.kt") + public void testImplicitThis() throws Exception { + runTest("compiler/testData/debug/stepping/implicitThis.kt"); + } + + @Test + @TestMetadata("implicitThisOnInvoke.kt") + public void testImplicitThisOnInvoke() throws Exception { + runTest("compiler/testData/debug/stepping/implicitThisOnInvoke.kt"); + } + + @Test + @TestMetadata("inTheEndOfLambdaArgumentOfInlineCall.kt") + public void testInTheEndOfLambdaArgumentOfInlineCall() throws Exception { + runTest("compiler/testData/debug/stepping/inTheEndOfLambdaArgumentOfInlineCall.kt"); + } + + @Test + @TestMetadata("initBlocks.kt") + public void testInitBlocks() throws Exception { + runTest("compiler/testData/debug/stepping/initBlocks.kt"); + } + + @Test + @TestMetadata("initBlocksCompanion.kt") + public void testInitBlocksCompanion() throws Exception { + runTest("compiler/testData/debug/stepping/initBlocksCompanion.kt"); + } + + @Test + @TestMetadata("inlineCallableReference.kt") + public void testInlineCallableReference() throws Exception { + runTest("compiler/testData/debug/stepping/inlineCallableReference.kt"); + } + + @Test + @TestMetadata("inlineNamedCallableReference.kt") + public void testInlineNamedCallableReference() throws Exception { + runTest("compiler/testData/debug/stepping/inlineNamedCallableReference.kt"); + } + + @Test + @TestMetadata("inlineSimpleCall.kt") + public void testInlineSimpleCall() throws Exception { + runTest("compiler/testData/debug/stepping/inlineSimpleCall.kt"); + } + + @Test + @TestMetadata("kt15259.kt") + public void testKt15259() throws Exception { + runTest("compiler/testData/debug/stepping/kt15259.kt"); + } + + @Test + @TestMetadata("kt29179.kt") + public void testKt29179() throws Exception { + runTest("compiler/testData/debug/stepping/kt29179.kt"); + } + + @Test + @TestMetadata("kt42208.kt") + public void testKt42208() throws Exception { + runTest("compiler/testData/debug/stepping/kt42208.kt"); + } + + @Test + @TestMetadata("kt42208b.kt") + public void testKt42208b() throws Exception { + runTest("compiler/testData/debug/stepping/kt42208b.kt"); + } + + @Test + @TestMetadata("kt42208c.kt") + public void testKt42208c() throws Exception { + runTest("compiler/testData/debug/stepping/kt42208c.kt"); + } + + @Test + @TestMetadata("lambdaStepInline.kt") + public void testLambdaStepInline() throws Exception { + runTest("compiler/testData/debug/stepping/lambdaStepInline.kt"); + } + + @Test + @TestMetadata("lambdaStepInlineWithDefaults.kt") + public void testLambdaStepInlineWithDefaults() throws Exception { + runTest("compiler/testData/debug/stepping/lambdaStepInlineWithDefaults.kt"); + } + + @Test + @TestMetadata("lineNumberAfterInline.kt") + public void testLineNumberAfterInline() throws Exception { + runTest("compiler/testData/debug/stepping/lineNumberAfterInline.kt"); + } + + @Test + @TestMetadata("linenumberForOneParametersArgumentCall.kt") + public void testLinenumberForOneParametersArgumentCall() throws Exception { + runTest("compiler/testData/debug/stepping/linenumberForOneParametersArgumentCall.kt"); + } + + @Test + @TestMetadata("localFunction.kt") + public void testLocalFunction() throws Exception { + runTest("compiler/testData/debug/stepping/localFunction.kt"); + } + + @Test + @TestMetadata("localFunctionWIthOnelineExpressionBody.kt") + public void testLocalFunctionWIthOnelineExpressionBody() throws Exception { + runTest("compiler/testData/debug/stepping/localFunctionWIthOnelineExpressionBody.kt"); + } + + @Test + @TestMetadata("localProperty.kt") + public void testLocalProperty() throws Exception { + runTest("compiler/testData/debug/stepping/localProperty.kt"); + } + + @Test + @TestMetadata("multiModule.kt") + public void testMultiModule() throws Exception { + runTest("compiler/testData/debug/stepping/multiModule.kt"); + } + + @Test + @TestMetadata("multilineExpression.kt") + public void testMultilineExpression() throws Exception { + runTest("compiler/testData/debug/stepping/multilineExpression.kt"); + } + + @Test + @TestMetadata("multilineFunctionCall.kt") + public void testMultilineFunctionCall() throws Exception { + runTest("compiler/testData/debug/stepping/multilineFunctionCall.kt"); + } + + @Test + @TestMetadata("multilineInfixCall.kt") + public void testMultilineInfixCall() throws Exception { + runTest("compiler/testData/debug/stepping/multilineInfixCall.kt"); + } + + @Test + @TestMetadata("namedCallableReference.kt") + public void testNamedCallableReference() throws Exception { + runTest("compiler/testData/debug/stepping/namedCallableReference.kt"); + } + + @Test + @TestMetadata("nestedInline.kt") + public void testNestedInline() throws Exception { + runTest("compiler/testData/debug/stepping/nestedInline.kt"); + } + + @Test + @TestMetadata("noParametersArgumentCallInExpression.kt") + public void testNoParametersArgumentCallInExpression() throws Exception { + runTest("compiler/testData/debug/stepping/noParametersArgumentCallInExpression.kt"); + } + + @Test + @TestMetadata("nullcheck.kt") + public void testNullcheck() throws Exception { + runTest("compiler/testData/debug/stepping/nullcheck.kt"); + } + + @Test + @TestMetadata("overridenGetterSetter.kt") + public void testOverridenGetterSetter() throws Exception { + runTest("compiler/testData/debug/stepping/overridenGetterSetter.kt"); + } + + @Test + @TestMetadata("primitiveNullChecks.kt") + public void testPrimitiveNullChecks() throws Exception { + runTest("compiler/testData/debug/stepping/primitiveNullChecks.kt"); + } + + @Test + @TestMetadata("propertyAccessor.kt") + public void testPropertyAccessor() throws Exception { + runTest("compiler/testData/debug/stepping/propertyAccessor.kt"); + } + + @Test + @TestMetadata("psvm.kt") + public void testPsvm() throws Exception { + runTest("compiler/testData/debug/stepping/psvm.kt"); + } + + @Test + @TestMetadata("recursion.kt") + public void testRecursion() throws Exception { + runTest("compiler/testData/debug/stepping/recursion.kt"); + } + + @Test + @TestMetadata("simpleDefaultArg.kt") + public void testSimpleDefaultArg() throws Exception { + runTest("compiler/testData/debug/stepping/simpleDefaultArg.kt"); + } + + @Test + @TestMetadata("simpleDefaultArgWithInline.kt") + public void testSimpleDefaultArgWithInline() throws Exception { + runTest("compiler/testData/debug/stepping/simpleDefaultArgWithInline.kt"); + } + + @Test + @TestMetadata("simpleInlineDefaultArg.kt") + public void testSimpleInlineDefaultArg() throws Exception { + runTest("compiler/testData/debug/stepping/simpleInlineDefaultArg.kt"); + } + + @Test + @TestMetadata("simpleSmap.kt") + public void testSimpleSmap() throws Exception { + runTest("compiler/testData/debug/stepping/simpleSmap.kt"); + } + + @Test + @TestMetadata("smapInlineAsArgument.kt") + public void testSmapInlineAsArgument() throws Exception { + runTest("compiler/testData/debug/stepping/smapInlineAsArgument.kt"); + } + + @Test + @TestMetadata("smapInlineAsInfixArgument.kt") + public void testSmapInlineAsInfixArgument() throws Exception { + runTest("compiler/testData/debug/stepping/smapInlineAsInfixArgument.kt"); + } + + @Test + @TestMetadata("smapInlineAsInlineArgument.kt") + public void testSmapInlineAsInlineArgument() throws Exception { + runTest("compiler/testData/debug/stepping/smapInlineAsInlineArgument.kt"); + } + + @Test + @TestMetadata("smapInlineInIntrinsicArgument.kt") + public void testSmapInlineInIntrinsicArgument() throws Exception { + runTest("compiler/testData/debug/stepping/smapInlineInIntrinsicArgument.kt"); + } + + @Test + @TestMetadata("stringSwitches.kt") + public void testStringSwitches() throws Exception { + runTest("compiler/testData/debug/stepping/stringSwitches.kt"); + } + + @Test + @TestMetadata("stringSwitchesSmall.kt") + public void testStringSwitchesSmall() throws Exception { + runTest("compiler/testData/debug/stepping/stringSwitchesSmall.kt"); + } + + @Test + @TestMetadata("suspendFunWithLambdaParameter.kt") + public void testSuspendFunWithLambdaParameter() throws Exception { + runTest("compiler/testData/debug/stepping/suspendFunWithLambdaParameter.kt"); + } + + @Test + @TestMetadata("suspendFunWithSuspendLambdaParameter.kt") + public void testSuspendFunWithSuspendLambdaParameter() throws Exception { + runTest("compiler/testData/debug/stepping/suspendFunWithSuspendLambdaParameter.kt"); + } + + @Test + @TestMetadata("throwException.kt") + public void testThrowException() throws Exception { + runTest("compiler/testData/debug/stepping/throwException.kt"); + } + + @Test + @TestMetadata("topLevel.kt") + public void testTopLevel() throws Exception { + runTest("compiler/testData/debug/stepping/topLevel.kt"); + } + + @Test + @TestMetadata("trait.kt") + public void testTrait() throws Exception { + runTest("compiler/testData/debug/stepping/trait.kt"); + } + + @Test + @TestMetadata("tryCatch.kt") + public void testTryCatch() throws Exception { + runTest("compiler/testData/debug/stepping/tryCatch.kt"); + } + + @Test + @TestMetadata("tryCatchExpression.kt") + public void testTryCatchExpression() throws Exception { + runTest("compiler/testData/debug/stepping/tryCatchExpression.kt"); + } + + @Test + @TestMetadata("tryCatchFinally.kt") + public void testTryCatchFinally() throws Exception { + runTest("compiler/testData/debug/stepping/tryCatchFinally.kt"); + } + + @Test + @TestMetadata("tryFinally.kt") + public void testTryFinally() throws Exception { + runTest("compiler/testData/debug/stepping/tryFinally.kt"); + } + + @Test + @TestMetadata("variablesWithoutInitializer.kt") + public void testVariablesWithoutInitializer() throws Exception { + runTest("compiler/testData/debug/stepping/variablesWithoutInitializer.kt"); + } + + @Test + @TestMetadata("voidLambdaStepInline.kt") + public void testVoidLambdaStepInline() throws Exception { + runTest("compiler/testData/debug/stepping/voidLambdaStepInline.kt"); + } + + @Test + @TestMetadata("when.kt") + public void testWhen() throws Exception { + runTest("compiler/testData/debug/stepping/when.kt"); + } + + @Test + @TestMetadata("whenComplicatedSubject.kt") + public void testWhenComplicatedSubject() throws Exception { + runTest("compiler/testData/debug/stepping/whenComplicatedSubject.kt"); + } + + @Test + @TestMetadata("whenConstant.kt") + public void testWhenConstant() throws Exception { + runTest("compiler/testData/debug/stepping/whenConstant.kt"); + } + + @Test + @TestMetadata("whenExpr.kt") + public void testWhenExpr() throws Exception { + runTest("compiler/testData/debug/stepping/whenExpr.kt"); + } + + @Test + @TestMetadata("whenInConjunction.kt") + public void testWhenInConjunction() throws Exception { + runTest("compiler/testData/debug/stepping/whenInConjunction.kt"); + } + + @Test + @TestMetadata("whenInDisjunction.kt") + public void testWhenInDisjunction() throws Exception { + runTest("compiler/testData/debug/stepping/whenInDisjunction.kt"); + } + + @Test + @TestMetadata("whenInGeneralObjectComparison.kt") + public void testWhenInGeneralObjectComparison() throws Exception { + runTest("compiler/testData/debug/stepping/whenInGeneralObjectComparison.kt"); + } + + @Test + @TestMetadata("whenInNegation.kt") + public void testWhenInNegation() throws Exception { + runTest("compiler/testData/debug/stepping/whenInNegation.kt"); + } + + @Test + @TestMetadata("whenInNullComparison.kt") + public void testWhenInNullComparison() throws Exception { + runTest("compiler/testData/debug/stepping/whenInNullComparison.kt"); + } + + @Test + @TestMetadata("whenInPrimitiveToObjectComparison.kt") + public void testWhenInPrimitiveToObjectComparison() throws Exception { + runTest("compiler/testData/debug/stepping/whenInPrimitiveToObjectComparison.kt"); + } + + @Test + @TestMetadata("whenInZeroComparison.kt") + public void testWhenInZeroComparison() throws Exception { + runTest("compiler/testData/debug/stepping/whenInZeroComparison.kt"); + } + + @Test + @TestMetadata("whenIsChecks.kt") + public void testWhenIsChecks() throws Exception { + runTest("compiler/testData/debug/stepping/whenIsChecks.kt"); + } + + @Test + @TestMetadata("whenMultiLine.kt") + public void testWhenMultiLine() throws Exception { + runTest("compiler/testData/debug/stepping/whenMultiLine.kt"); + } + + @Test + @TestMetadata("whenMultiLineSubject.kt") + public void testWhenMultiLineSubject() throws Exception { + runTest("compiler/testData/debug/stepping/whenMultiLineSubject.kt"); + } + + @Test + @TestMetadata("whenNullalbeSubject.kt") + public void testWhenNullalbeSubject() throws Exception { + runTest("compiler/testData/debug/stepping/whenNullalbeSubject.kt"); + } + + @Test + @TestMetadata("whenSubject.kt") + public void testWhenSubject() throws Exception { + runTest("compiler/testData/debug/stepping/whenSubject.kt"); + } + + @Test + @TestMetadata("whenSubject2.kt") + public void testWhenSubject2() throws Exception { + runTest("compiler/testData/debug/stepping/whenSubject2.kt"); + } + + @Test + @TestMetadata("whenWithInlineInCondition.kt") + public void testWhenWithInlineInCondition() throws Exception { + runTest("compiler/testData/debug/stepping/whenWithInlineInCondition.kt"); + } + + @Test + @TestMetadata("while.kt") + public void testWhile() throws Exception { + runTest("compiler/testData/debug/stepping/while.kt"); + } +}