From 9e357354fb410834f74d7a519daff49e91a2d967 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Fri, 28 Aug 2020 20:56:28 +0200 Subject: [PATCH] Add JVM/JVM_IR mixed compilation tests for compileKotlinAgainstKotlin/boxInline --- .../anonymousObjectInDefault.kt | 2 +- .../anonymousObject/capturedLocalFun.kt | 2 +- .../superConstructorWithObjectParameter.kt | 2 +- .../varargAndDefaultParameters.kt | 2 +- .../assert/jvmInlineUsedAsNoinline.kt | 2 +- .../bound/emptyLhsOnInlineProperty.kt | 2 +- .../smap/anonymous/lambdaOnInlineCallSite.kt | 2 +- .../smap/anonymous/objectOnInlineCallSite.kt | 2 +- .../suspend/inlineSuspendInMultifileClass.kt | 2 +- .../boxInline/suspend/nonLocalReturn.kt | 2 +- .../protectedMembersFromSuper.kt | 2 +- ...bstractCompileKotlinAgainstKotlinTest.java | 15 +- ...tIrCompileKotlinAgainstInlineKotlinTest.kt | 16 +- ...bstractIrCompileKotlinAgainstKotlinTest.kt | 16 +- .../jetbrains/kotlin/test/TargetBackend.kt | 2 + ...JvmIrAgainstOldBoxInlineTestGenerated.java | 4418 +++++++++++++++++ .../ir/JvmIrAgainstOldBoxTestGenerated.java | 639 +++ ...JvmOldAgainstIrBoxInlineTestGenerated.java | 4418 +++++++++++++++++ .../ir/JvmOldAgainstIrBoxTestGenerated.java | 639 +++ .../generators/tests/GenerateCompilerTests.kt | 20 + 20 files changed, 10190 insertions(+), 15 deletions(-) create mode 100644 compiler/tests/org/jetbrains/kotlin/codegen/ir/JvmIrAgainstOldBoxInlineTestGenerated.java create mode 100644 compiler/tests/org/jetbrains/kotlin/codegen/ir/JvmIrAgainstOldBoxTestGenerated.java create mode 100644 compiler/tests/org/jetbrains/kotlin/codegen/ir/JvmOldAgainstIrBoxInlineTestGenerated.java create mode 100644 compiler/tests/org/jetbrains/kotlin/codegen/ir/JvmOldAgainstIrBoxTestGenerated.java diff --git a/compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectInDefault.kt b/compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectInDefault.kt index 4e61ed1f431..8fcee73bf0f 100644 --- a/compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectInDefault.kt +++ b/compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectInDefault.kt @@ -1,5 +1,5 @@ // IGNORE_BACKEND: JVM -// IGNORE_BACKEND_MULTI_MODULE: JVM +// IGNORE_BACKEND_MULTI_MODULE: JVM, JVM_MULTI_MODULE_OLD_AGAINST_IR // NO_CHECK_LAMBDA_INLINING // FILE: 1.kt diff --git a/compiler/testData/codegen/boxInline/anonymousObject/capturedLocalFun.kt b/compiler/testData/codegen/boxInline/anonymousObject/capturedLocalFun.kt index 554a4996cbe..8d1bc6618d3 100644 --- a/compiler/testData/codegen/boxInline/anonymousObject/capturedLocalFun.kt +++ b/compiler/testData/codegen/boxInline/anonymousObject/capturedLocalFun.kt @@ -1,5 +1,5 @@ // IGNORE_BACKEND: JVM -// IGNORE_BACKEND_MULTI_MODULE: JVM +// IGNORE_BACKEND_MULTI_MODULE: JVM, JVM_MULTI_MODULE_OLD_AGAINST_IR // NO_CHECK_LAMBDA_INLINING // FILE: 1.kt diff --git a/compiler/testData/codegen/boxInline/anonymousObject/superConstructorWithObjectParameter.kt b/compiler/testData/codegen/boxInline/anonymousObject/superConstructorWithObjectParameter.kt index 3a23da3fecf..f30029521dc 100644 --- a/compiler/testData/codegen/boxInline/anonymousObject/superConstructorWithObjectParameter.kt +++ b/compiler/testData/codegen/boxInline/anonymousObject/superConstructorWithObjectParameter.kt @@ -1,5 +1,5 @@ // IGNORE_BACKEND: JVM -// IGNORE_BACKEND_MULTI_MODULE: JVM +// IGNORE_BACKEND_MULTI_MODULE: JVM, JVM_MULTI_MODULE_IR_AGAINST_OLD // FILE: 1.kt package test diff --git a/compiler/testData/codegen/boxInline/argumentOrder/varargAndDefaultParameters.kt b/compiler/testData/codegen/boxInline/argumentOrder/varargAndDefaultParameters.kt index 148fcabe22b..b64b188da45 100644 --- a/compiler/testData/codegen/boxInline/argumentOrder/varargAndDefaultParameters.kt +++ b/compiler/testData/codegen/boxInline/argumentOrder/varargAndDefaultParameters.kt @@ -1,7 +1,7 @@ // IGNORE_BACKEND: JVM_IR // IGNORE_BACKEND: JS, JS_IR // IGNORE_BACKEND: JS_IR_ES6 -// IGNORE_BACKEND_MULTI_MODULE: JVM_IR +// IGNORE_BACKEND_MULTI_MODULE: JVM_IR, JVM_MULTI_MODULE_IR_AGAINST_OLD // NO_CHECK_LAMBDA_INLINING // FILE: 1.kt // WITH_RUNTIME diff --git a/compiler/testData/codegen/boxInline/assert/jvmInlineUsedAsNoinline.kt b/compiler/testData/codegen/boxInline/assert/jvmInlineUsedAsNoinline.kt index 650c09dc163..4e94b54888c 100644 --- a/compiler/testData/codegen/boxInline/assert/jvmInlineUsedAsNoinline.kt +++ b/compiler/testData/codegen/boxInline/assert/jvmInlineUsedAsNoinline.kt @@ -1,6 +1,6 @@ // Not a multi-module test. // TARGET_BACKEND: JVM -// IGNORE_BACKEND_MULTI_MODULE: JVM, JVM_IR +// IGNORE_BACKEND_MULTI_MODULE: JVM, JVM_IR, JVM_MULTI_MODULE_OLD_AGAINST_IR, JVM_MULTI_MODULE_IR_AGAINST_OLD // FILE: A.kt // KOTLIN_CONFIGURATION_FLAGS: ASSERTIONS_MODE=jvm // WITH_RUNTIME diff --git a/compiler/testData/codegen/boxInline/callableReference/bound/emptyLhsOnInlineProperty.kt b/compiler/testData/codegen/boxInline/callableReference/bound/emptyLhsOnInlineProperty.kt index c44e107aedd..7ff39b59c54 100644 --- a/compiler/testData/codegen/boxInline/callableReference/bound/emptyLhsOnInlineProperty.kt +++ b/compiler/testData/codegen/boxInline/callableReference/bound/emptyLhsOnInlineProperty.kt @@ -1,5 +1,5 @@ // IGNORE_BACKEND: JVM -// IGNORE_BACKEND_MULTI_MODULE: JVM +// IGNORE_BACKEND_MULTI_MODULE: JVM, JVM_MULTI_MODULE_IR_AGAINST_OLD // FILE: 1.kt package test diff --git a/compiler/testData/codegen/boxInline/smap/anonymous/lambdaOnInlineCallSite.kt b/compiler/testData/codegen/boxInline/smap/anonymous/lambdaOnInlineCallSite.kt index d61decacfec..d7f7708ea70 100644 --- a/compiler/testData/codegen/boxInline/smap/anonymous/lambdaOnInlineCallSite.kt +++ b/compiler/testData/codegen/boxInline/smap/anonymous/lambdaOnInlineCallSite.kt @@ -1,4 +1,4 @@ -// IGNORE_BACKEND_MULTI_MODULE: JVM_IR +// IGNORE_BACKEND_MULTI_MODULE: JVM_IR, JVM_MULTI_MODULE_IR_AGAINST_OLD // FILE: 1.kt package builders diff --git a/compiler/testData/codegen/boxInline/smap/anonymous/objectOnInlineCallSite.kt b/compiler/testData/codegen/boxInline/smap/anonymous/objectOnInlineCallSite.kt index 39ebab6017a..aa075edbced 100644 --- a/compiler/testData/codegen/boxInline/smap/anonymous/objectOnInlineCallSite.kt +++ b/compiler/testData/codegen/boxInline/smap/anonymous/objectOnInlineCallSite.kt @@ -1,4 +1,4 @@ -// IGNORE_BACKEND_MULTI_MODULE: JVM_IR +// IGNORE_BACKEND_MULTI_MODULE: JVM_IR, JVM_MULTI_MODULE_IR_AGAINST_OLD // FILE: 1.kt package builders diff --git a/compiler/testData/codegen/boxInline/suspend/inlineSuspendInMultifileClass.kt b/compiler/testData/codegen/boxInline/suspend/inlineSuspendInMultifileClass.kt index ddf2fbdc3bf..65b84089576 100644 --- a/compiler/testData/codegen/boxInline/suspend/inlineSuspendInMultifileClass.kt +++ b/compiler/testData/codegen/boxInline/suspend/inlineSuspendInMultifileClass.kt @@ -7,7 +7,7 @@ // The lambda in box() attempts to store the result in a null Ref for some reason. // IGNORE_BACKEND: JVM -// IGNORE_BACKEND_MULTI_MODULE: JVM +// IGNORE_BACKEND_MULTI_MODULE: JVM, JVM_MULTI_MODULE_OLD_AGAINST_IR @file:JvmMultifileClass @file:JvmName("XKt") diff --git a/compiler/testData/codegen/boxInline/suspend/nonLocalReturn.kt b/compiler/testData/codegen/boxInline/suspend/nonLocalReturn.kt index b919d7dd95f..c55381f9a6d 100644 --- a/compiler/testData/codegen/boxInline/suspend/nonLocalReturn.kt +++ b/compiler/testData/codegen/boxInline/suspend/nonLocalReturn.kt @@ -1,7 +1,7 @@ // WITH_RUNTIME // WITH_COROUTINES // IGNORE_BACKEND: JVM -// IGNORE_BACKEND_MULTI_MODULE: JVM +// IGNORE_BACKEND_MULTI_MODULE: JVM, JVM_MULTI_MODULE_OLD_AGAINST_IR // NO_CHECK_LAMBDA_INLINING // FILE: a.kt diff --git a/compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/protectedMembersFromSuper.kt b/compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/protectedMembersFromSuper.kt index f2baf76101f..12058d57af8 100644 --- a/compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/protectedMembersFromSuper.kt +++ b/compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/protectedMembersFromSuper.kt @@ -1,6 +1,6 @@ // !LANGUAGE: -ProhibitProtectedCallFromInline // IGNORE_BACKEND: JVM -// IGNORE_BACKEND_MULTI_MODULE: JVM +// IGNORE_BACKEND_MULTI_MODULE: JVM, JVM_MULTI_MODULE_IR_AGAINST_OLD // FILE: 1.kt package test diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractCompileKotlinAgainstKotlinTest.java b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractCompileKotlinAgainstKotlinTest.java index 5df846b9504..1079b2c6760 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractCompileKotlinAgainstKotlinTest.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractCompileKotlinAgainstKotlinTest.java @@ -22,6 +22,7 @@ import org.jetbrains.kotlin.psi.KtFile; import org.jetbrains.kotlin.test.ConfigurationKind; import org.jetbrains.kotlin.test.InTextDirectivesUtils; import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.utils.ExceptionUtilsKt; import java.io.File; @@ -99,11 +100,21 @@ public abstract class AbstractCompileKotlinAgainstKotlinTest extends CodegenTest ); } + @NotNull + protected TargetBackend getBackendA() { + return getBackend(); + } + + @NotNull + protected TargetBackend getBackendB() { + return getBackend(); + } + @NotNull private ClassFileFactory compileA(@NotNull TestFile testFile, List files) { Disposable compileDisposable = createDisposable("compileA"); CompilerConfiguration configuration = createConfiguration( - ConfigurationKind.ALL, getTestJdkKind(files), getBackend(), + ConfigurationKind.ALL, getTestJdkKind(files), getBackendA(), Collections.singletonList(KotlinTestUtils.getAnnotationsJar()), Collections.emptyList(), Collections.singletonList(testFile) ); @@ -126,7 +137,7 @@ public abstract class AbstractCompileKotlinAgainstKotlinTest extends CodegenTest private ClassFileFactory compileB(@NotNull TestFile testFile, List files) { String commonHeader = StringsKt.substringBefore(files.get(0).content, "FILE:", ""); CompilerConfiguration configuration = createConfiguration( - ConfigurationKind.ALL, getTestJdkKind(files), getBackend(), + ConfigurationKind.ALL, getTestJdkKind(files), getBackendB(), Arrays.asList(KotlinTestUtils.getAnnotationsJar(), aDir), Collections.emptyList(), Arrays.asList(testFile, new TestFile("header", commonHeader)) ); diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCompileKotlinAgainstInlineKotlinTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCompileKotlinAgainstInlineKotlinTest.kt index 043d71e72ab..ac226c250e3 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCompileKotlinAgainstInlineKotlinTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCompileKotlinAgainstInlineKotlinTest.kt @@ -9,5 +9,19 @@ import org.jetbrains.kotlin.codegen.AbstractCompileKotlinAgainstInlineKotlinTest import org.jetbrains.kotlin.test.TargetBackend abstract class AbstractIrCompileKotlinAgainstInlineKotlinTest : AbstractCompileKotlinAgainstInlineKotlinTest() { - override val backend = TargetBackend.JVM_IR + override val backend: TargetBackend get() = TargetBackend.JVM_IR +} + +abstract class AbstractJvmIrAgainstOldBoxInlineTest : AbstractIrCompileKotlinAgainstInlineKotlinTest() { + override val backend: TargetBackend get() = TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD + + override fun getBackendA(): TargetBackend = TargetBackend.JVM + override fun getBackendB(): TargetBackend = TargetBackend.JVM_IR +} + +abstract class AbstractJvmOldAgainstIrBoxInlineTest : AbstractIrCompileKotlinAgainstInlineKotlinTest() { + override val backend: TargetBackend get() = TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR + + override fun getBackendA(): TargetBackend = TargetBackend.JVM_IR + override fun getBackendB(): TargetBackend = TargetBackend.JVM } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCompileKotlinAgainstKotlinTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCompileKotlinAgainstKotlinTest.kt index 65a8c3d362b..ea018748120 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCompileKotlinAgainstKotlinTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/ir/AbstractIrCompileKotlinAgainstKotlinTest.kt @@ -9,5 +9,19 @@ import org.jetbrains.kotlin.codegen.AbstractCompileKotlinAgainstKotlinTest import org.jetbrains.kotlin.test.TargetBackend abstract class AbstractIrCompileKotlinAgainstKotlinTest : AbstractCompileKotlinAgainstKotlinTest() { - override val backend = TargetBackend.JVM_IR + override val backend: TargetBackend get() = TargetBackend.JVM_IR +} + +abstract class AbstractJvmIrAgainstOldBoxTest : AbstractIrCompileKotlinAgainstKotlinTest() { + override val backend: TargetBackend get() = TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD + + override fun getBackendA(): TargetBackend = TargetBackend.JVM + override fun getBackendB(): TargetBackend = TargetBackend.JVM_IR +} + +abstract class AbstractJvmOldAgainstIrBoxTest : AbstractIrCompileKotlinAgainstKotlinTest() { + override val backend: TargetBackend get() = TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR + + override fun getBackendA(): TargetBackend = TargetBackend.JVM_IR + override fun getBackendB(): TargetBackend = TargetBackend.JVM } diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/test/TargetBackend.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/test/TargetBackend.kt index d54656a7606..450f0c4679d 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/test/TargetBackend.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/test/TargetBackend.kt @@ -13,6 +13,8 @@ enum class TargetBackend( JVM(false), JVM_OLD(false, JVM), JVM_IR(true, JVM), + JVM_MULTI_MODULE_IR_AGAINST_OLD(true, JVM_IR), + JVM_MULTI_MODULE_OLD_AGAINST_IR(false, JVM), JS(false), JS_IR(true, JS), JS_IR_ES6(true, JS_IR), diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/ir/JvmIrAgainstOldBoxInlineTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/ir/JvmIrAgainstOldBoxInlineTestGenerated.java new file mode 100644 index 00000000000..94e391a6b19 --- /dev/null +++ b/compiler/tests/org/jetbrains/kotlin/codegen/ir/JvmIrAgainstOldBoxInlineTestGenerated.java @@ -0,0 +1,4418 @@ +/* + * Copyright 2010-2020 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.codegen.ir; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; +import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.TargetBackend; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.runner.RunWith; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("compiler/testData/codegen/boxInline") +@TestDataPath("$PROJECT_ROOT") +@RunWith(JUnit3RunnerWithInners.class) +public class JvmIrAgainstOldBoxInlineTestGenerated extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInBoxInline() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AnonymousObject extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInAnonymousObject() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("anonymousObjectInDefault.kt") + public void testAnonymousObjectInDefault() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectInDefault.kt"); + } + + @TestMetadata("anonymousObjectOnCallSite.kt") + public void testAnonymousObjectOnCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectOnCallSite.kt"); + } + + @TestMetadata("anonymousObjectOnCallSiteSuperParams.kt") + public void testAnonymousObjectOnCallSiteSuperParams() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectOnCallSiteSuperParams.kt"); + } + + @TestMetadata("anonymousObjectOnDeclarationSite.kt") + public void testAnonymousObjectOnDeclarationSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectOnDeclarationSite.kt"); + } + + @TestMetadata("anonymousObjectOnDeclarationSiteSuperParams.kt") + public void testAnonymousObjectOnDeclarationSiteSuperParams() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectOnDeclarationSiteSuperParams.kt"); + } + + @TestMetadata("capturedLambdaInInline.kt") + public void testCapturedLambdaInInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/capturedLambdaInInline.kt"); + } + + @TestMetadata("capturedLambdaInInline2.kt") + public void testCapturedLambdaInInline2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/capturedLambdaInInline2.kt"); + } + + @TestMetadata("capturedLambdaInInline3.kt") + public void testCapturedLambdaInInline3() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/capturedLambdaInInline3.kt"); + } + + @TestMetadata("capturedLambdaInInlineObject.kt") + public void testCapturedLambdaInInlineObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/capturedLambdaInInlineObject.kt"); + } + + @TestMetadata("capturedLocalFun.kt") + public void testCapturedLocalFun() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/capturedLocalFun.kt"); + } + + @TestMetadata("capturedLocalFunRef.kt") + public void testCapturedLocalFunRef() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/capturedLocalFunRef.kt"); + } + + @TestMetadata("changingReturnType.kt") + public void testChangingReturnType() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/changingReturnType.kt"); + } + + @TestMetadata("constructorVisibility.kt") + public void testConstructorVisibility() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/constructorVisibility.kt"); + } + + @TestMetadata("constructorVisibilityInConstLambda.kt") + public void testConstructorVisibilityInConstLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/constructorVisibilityInConstLambda.kt"); + } + + @TestMetadata("constructorVisibilityInLambda.kt") + public void testConstructorVisibilityInLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/constructorVisibilityInLambda.kt"); + } + + @TestMetadata("defineClass.kt") + public void testDefineClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/defineClass.kt"); + } + + @TestMetadata("functionExpression.kt") + public void testFunctionExpression() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/functionExpression.kt"); + } + + @TestMetadata("inlineCallInsideInlineLambda.kt") + public void testInlineCallInsideInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/inlineCallInsideInlineLambda.kt"); + } + + @TestMetadata("kt13133.kt") + public void testKt13133() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt13133.kt"); + } + + @TestMetadata("kt13182.kt") + public void testKt13182() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt13182.kt"); + } + + @TestMetadata("kt13374.kt") + public void testKt13374() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt13374.kt"); + } + + @TestMetadata("kt14011.kt") + public void testKt14011() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt14011.kt"); + } + + @TestMetadata("kt14011_2.kt") + public void testKt14011_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt14011_2.kt"); + } + + @TestMetadata("kt14011_3.kt") + public void testKt14011_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt14011_3.kt"); + } + + @TestMetadata("kt15751.kt") + public void testKt15751() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt15751.kt"); + } + + @TestMetadata("kt16193.kt") + public void testKt16193() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt16193.kt"); + } + + @TestMetadata("kt17972.kt") + public void testKt17972() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972.kt"); + } + + @TestMetadata("kt17972_2.kt") + public void testKt17972_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_2.kt"); + } + + @TestMetadata("kt17972_3.kt") + public void testKt17972_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_3.kt"); + } + + @TestMetadata("kt17972_4.kt") + public void testKt17972_4() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_4.kt"); + } + + @TestMetadata("kt17972_5.kt") + public void testKt17972_5() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_5.kt"); + } + + @TestMetadata("kt17972_super.kt") + public void testKt17972_super() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_super.kt"); + } + + @TestMetadata("kt17972_super2.kt") + public void testKt17972_super2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_super2.kt"); + } + + @TestMetadata("kt17972_super3.kt") + public void testKt17972_super3() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_super3.kt"); + } + + @TestMetadata("kt19389.kt") + public void testKt19389() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt19389.kt"); + } + + @TestMetadata("kt19399.kt") + public void testKt19399() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt19399.kt"); + } + + @TestMetadata("kt19434.kt") + public void testKt19434() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt19434.kt"); + } + + @TestMetadata("kt19434_2.kt") + public void testKt19434_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt19434_2.kt"); + } + + @TestMetadata("kt19723.kt") + public void testKt19723() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt19723.kt"); + } + + @TestMetadata("kt34656.kt") + public void testKt34656() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt34656.kt"); + } + + @TestMetadata("kt38197.kt") + public void testKt38197() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt38197.kt"); + } + + @TestMetadata("kt6552.kt") + public void testKt6552() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt6552.kt"); + } + + @TestMetadata("kt8133.kt") + public void testKt8133() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt8133.kt"); + } + + @TestMetadata("kt9064.kt") + public void testKt9064() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt9064.kt"); + } + + @TestMetadata("kt9064v2.kt") + public void testKt9064v2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt9064v2.kt"); + } + + @TestMetadata("kt9591.kt") + public void testKt9591() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt9591.kt"); + } + + @TestMetadata("kt9877.kt") + public void testKt9877() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt9877.kt"); + } + + @TestMetadata("kt9877_2.kt") + public void testKt9877_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt9877_2.kt"); + } + + @TestMetadata("objectInLambdaCapturesAnotherObject.kt") + public void testObjectInLambdaCapturesAnotherObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/objectInLambdaCapturesAnotherObject.kt"); + } + + @TestMetadata("safeCall.kt") + public void testSafeCall() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/safeCall.kt"); + } + + @TestMetadata("safeCall_2.kt") + public void testSafeCall_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/safeCall_2.kt"); + } + + @TestMetadata("sam.kt") + public void testSam() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/sam.kt"); + } + + @TestMetadata("sharedFromCrossinline.kt") + public void testSharedFromCrossinline() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/sharedFromCrossinline.kt"); + } + + @TestMetadata("superConstructorWithObjectParameter.kt") + public void testSuperConstructorWithObjectParameter() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/superConstructorWithObjectParameter.kt"); + } + + @TestMetadata("typeInfo.kt") + public void testTypeInfo() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/typeInfo.kt"); + } + + @TestMetadata("withInlineMethod.kt") + public void testWithInlineMethod() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/withInlineMethod.kt"); + } + + @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject/enumWhen") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class EnumWhen extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInEnumWhen() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumWhen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("callSite.kt") + public void testCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/enumWhen/callSite.kt"); + } + + @TestMetadata("declSite.kt") + public void testDeclSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/enumWhen/declSite.kt"); + } + + @TestMetadata("declSiteSeveralMappings.kt") + public void testDeclSiteSeveralMappings() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/enumWhen/declSiteSeveralMappings.kt"); + } + + @TestMetadata("declSiteSeveralMappingsDifOrder.kt") + public void testDeclSiteSeveralMappingsDifOrder() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/enumWhen/declSiteSeveralMappingsDifOrder.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ProperRecapturing extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInProperRecapturing() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("inlineChain.kt") + public void testInlineChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing/inlineChain.kt"); + } + + @TestMetadata("lambdaChain.kt") + public void testLambdaChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing/lambdaChain.kt"); + } + + @TestMetadata("lambdaChainSimple.kt") + public void testLambdaChainSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing/lambdaChainSimple.kt"); + } + + @TestMetadata("lambdaChain_2.kt") + public void testLambdaChain_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing/lambdaChain_2.kt"); + } + + @TestMetadata("lambdaChain_3.kt") + public void testLambdaChain_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing/lambdaChain_3.kt"); + } + + @TestMetadata("noInlineLambda.kt") + public void testNoInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing/noInlineLambda.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ProperRecapturingInClass extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInProperRecapturingInClass() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("inlineChain.kt") + public void testInlineChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/inlineChain.kt"); + } + + @TestMetadata("inlinelambdaChain.kt") + public void testInlinelambdaChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/inlinelambdaChain.kt"); + } + + @TestMetadata("lambdaChain.kt") + public void testLambdaChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/lambdaChain.kt"); + } + + @TestMetadata("lambdaChainSimple.kt") + public void testLambdaChainSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/lambdaChainSimple.kt"); + } + + @TestMetadata("lambdaChainSimple_2.kt") + public void testLambdaChainSimple_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/lambdaChainSimple_2.kt"); + } + + @TestMetadata("lambdaChain_2.kt") + public void testLambdaChain_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/lambdaChain_2.kt"); + } + + @TestMetadata("lambdaChain_3.kt") + public void testLambdaChain_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/lambdaChain_3.kt"); + } + + @TestMetadata("noCapturedThisOnCallSite.kt") + public void testNoCapturedThisOnCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/noCapturedThisOnCallSite.kt"); + } + + @TestMetadata("noInlineLambda.kt") + public void testNoInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/noInlineLambda.kt"); + } + + @TestMetadata("twoInlineLambda.kt") + public void testTwoInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/twoInlineLambda.kt"); + } + + @TestMetadata("twoInlineLambdaComplex.kt") + public void testTwoInlineLambdaComplex() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/twoInlineLambdaComplex.kt"); + } + + @TestMetadata("twoInlineLambdaComplex_2.kt") + public void testTwoInlineLambdaComplex_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/twoInlineLambdaComplex_2.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject/sam") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Sam extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInSam() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("anonymousObjectToSam.kt") + public void testAnonymousObjectToSam() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/sam/anonymousObjectToSam.kt"); + } + + @TestMetadata("kt17091.kt") + public void testKt17091() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/sam/kt17091.kt"); + } + + @TestMetadata("kt21671.kt") + public void testKt21671() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/sam/kt21671.kt"); + } + + @TestMetadata("kt21671_2.kt") + public void testKt21671_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/sam/kt21671_2.kt"); + } + + @TestMetadata("kt21671_3.kt") + public void testKt21671_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/sam/kt21671_3.kt"); + } + + @TestMetadata("kt22304.kt") + public void testKt22304() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/sam/kt22304.kt"); + } + + @TestMetadata("samOnCallSite.kt") + public void testSamOnCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/sam/samOnCallSite.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TwoCapturedReceivers extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInTwoCapturedReceivers() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("kt8668.kt") + public void testKt8668() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers/kt8668.kt"); + } + + @TestMetadata("kt8668_2.kt") + public void testKt8668_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers/kt8668_2.kt"); + } + + @TestMetadata("kt8668_3.kt") + public void testKt8668_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers/kt8668_3.kt"); + } + + @TestMetadata("twoDifferentDispatchReceivers.kt") + public void testTwoDifferentDispatchReceivers() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers/twoDifferentDispatchReceivers.kt"); + } + + @TestMetadata("twoExtensionReceivers.kt") + public void testTwoExtensionReceivers() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers/twoExtensionReceivers.kt"); + } + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/argumentOrder") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ArgumentOrder extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInArgumentOrder() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("boundFunctionReference.kt") + public void testBoundFunctionReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/boundFunctionReference.kt"); + } + + @TestMetadata("boundFunctionReference2.kt") + public void testBoundFunctionReference2() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/boundFunctionReference2.kt"); + } + + @TestMetadata("captured.kt") + public void testCaptured() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/captured.kt"); + } + + @TestMetadata("capturedInExtension.kt") + public void testCapturedInExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/capturedInExtension.kt"); + } + + @TestMetadata("defaultParametersAndLastVararg.kt") + public void testDefaultParametersAndLastVararg() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/defaultParametersAndLastVararg.kt"); + } + + @TestMetadata("extension.kt") + public void testExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/extension.kt"); + } + + @TestMetadata("extensionInClass.kt") + public void testExtensionInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/extensionInClass.kt"); + } + + @TestMetadata("lambdaMigration.kt") + public void testLambdaMigration() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/lambdaMigration.kt"); + } + + @TestMetadata("lambdaMigrationInClass.kt") + public void testLambdaMigrationInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/lambdaMigrationInClass.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/simple.kt"); + } + + @TestMetadata("simpleInClass.kt") + public void testSimpleInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/simpleInClass.kt"); + } + + @TestMetadata("varargAndDefaultParameters.kt") + public void testVarargAndDefaultParameters() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/varargAndDefaultParameters.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/arrayConvention") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ArrayConvention extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInArrayConvention() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/arrayConvention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("simpleAccess.kt") + public void testSimpleAccess() throws Exception { + runTest("compiler/testData/codegen/boxInline/arrayConvention/simpleAccess.kt"); + } + + @TestMetadata("simpleAccessInClass.kt") + public void testSimpleAccessInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/arrayConvention/simpleAccessInClass.kt"); + } + + @TestMetadata("simpleAccessWithDefault.kt") + public void testSimpleAccessWithDefault() throws Exception { + runTest("compiler/testData/codegen/boxInline/arrayConvention/simpleAccessWithDefault.kt"); + } + + @TestMetadata("simpleAccessWithDefaultInClass.kt") + public void testSimpleAccessWithDefaultInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/arrayConvention/simpleAccessWithDefaultInClass.kt"); + } + + @TestMetadata("simpleAccessWithLambda.kt") + public void testSimpleAccessWithLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/arrayConvention/simpleAccessWithLambda.kt"); + } + + @TestMetadata("simpleAccessWithLambdaInClass.kt") + public void testSimpleAccessWithLambdaInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/arrayConvention/simpleAccessWithLambdaInClass.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/assert") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Assert extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInAssert() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("jvmAssertInlineFunctionAssertionsDisabled.kt") + public void testJvmAssertInlineFunctionAssertionsDisabled() throws Exception { + runTest("compiler/testData/codegen/boxInline/assert/jvmAssertInlineFunctionAssertionsDisabled.kt"); + } + + @TestMetadata("jvmAssertInlineFunctionAssertionsEnabled.kt") + public void testJvmAssertInlineFunctionAssertionsEnabled() throws Exception { + runTest("compiler/testData/codegen/boxInline/assert/jvmAssertInlineFunctionAssertionsEnabled.kt"); + } + + @TestMetadata("jvmAssertInlineLambda.kt") + public void testJvmAssertInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/assert/jvmAssertInlineLambda.kt"); + } + + @TestMetadata("jvmClassInitializer.kt") + public void testJvmClassInitializer() throws Exception { + runTest("compiler/testData/codegen/boxInline/assert/jvmClassInitializer.kt"); + } + + @TestMetadata("jvmCompanion.kt") + public void testJvmCompanion() throws Exception { + runTest("compiler/testData/codegen/boxInline/assert/jvmCompanion.kt"); + } + + @TestMetadata("jvmCrossinlineLambda.kt") + public void testJvmCrossinlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/assert/jvmCrossinlineLambda.kt"); + } + + @TestMetadata("jvmCrossinlineLambda2.kt") + public void testJvmCrossinlineLambda2() throws Exception { + runTest("compiler/testData/codegen/boxInline/assert/jvmCrossinlineLambda2.kt"); + } + + @TestMetadata("jvmCrossinlineLambdaDeclarationSite.kt") + public void testJvmCrossinlineLambdaDeclarationSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/assert/jvmCrossinlineLambdaDeclarationSite.kt"); + } + + @TestMetadata("jvmCrossinlineLambdaDeclarationSiteOnly.kt") + public void testJvmCrossinlineLambdaDeclarationSiteOnly() throws Exception { + runTest("compiler/testData/codegen/boxInline/assert/jvmCrossinlineLambdaDeclarationSiteOnly.kt"); + } + + @TestMetadata("jvmCrossinlineSAMDeclarationSite.kt") + public void testJvmCrossinlineSAMDeclarationSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/assert/jvmCrossinlineSAMDeclarationSite.kt"); + } + + @TestMetadata("jvmDoubleInline.kt") + public void testJvmDoubleInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/assert/jvmDoubleInline.kt"); + } + + @TestMetadata("jvmInlineUsedAsNoinline.kt") + public void testJvmInlineUsedAsNoinline() throws Exception { + runTest("compiler/testData/codegen/boxInline/assert/jvmInlineUsedAsNoinline.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/builders") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Builders extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInBuilders() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/builders"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("builders.kt") + public void testBuilders() throws Exception { + runTest("compiler/testData/codegen/boxInline/builders/builders.kt"); + } + + @TestMetadata("buildersAndLambdaCapturing.kt") + public void testBuildersAndLambdaCapturing() throws Exception { + runTest("compiler/testData/codegen/boxInline/builders/buildersAndLambdaCapturing.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/bytecodePreprocessing") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class BytecodePreprocessing extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInBytecodePreprocessing() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/bytecodePreprocessing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("apiVersionAtLeast1.kt") + public void testApiVersionAtLeast1() throws Exception { + runTest("compiler/testData/codegen/boxInline/bytecodePreprocessing/apiVersionAtLeast1.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/callableReference") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CallableReference extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInCallableReference() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("classLevel.kt") + public void testClassLevel() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/classLevel.kt"); + } + + @TestMetadata("classLevel2.kt") + public void testClassLevel2() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/classLevel2.kt"); + } + + @TestMetadata("constructor.kt") + public void testConstructor() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/constructor.kt"); + } + + @TestMetadata("innerGenericConstuctor.kt") + public void testInnerGenericConstuctor() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/innerGenericConstuctor.kt"); + } + + @TestMetadata("intrinsic.kt") + public void testIntrinsic() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/intrinsic.kt"); + } + + @TestMetadata("jvmFieldProperty.kt") + public void testJvmFieldProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/jvmFieldProperty.kt"); + } + + @TestMetadata("kt15449.kt") + public void testKt15449() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/kt15449.kt"); + } + + @TestMetadata("kt15751_2.kt") + public void testKt15751_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/kt15751_2.kt"); + } + + @TestMetadata("kt16411.kt") + public void testKt16411() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/kt16411.kt"); + } + + @TestMetadata("kt35101.kt") + public void testKt35101() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/kt35101.kt"); + } + + @TestMetadata("propertyIntrinsic.kt") + public void testPropertyIntrinsic() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/propertyIntrinsic.kt"); + } + + @TestMetadata("propertyReference.kt") + public void testPropertyReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/propertyReference.kt"); + } + + @TestMetadata("topLevel.kt") + public void testTopLevel() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/topLevel.kt"); + } + + @TestMetadata("topLevelExtension.kt") + public void testTopLevelExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/topLevelExtension.kt"); + } + + @TestMetadata("topLevelProperty.kt") + public void testTopLevelProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/topLevelProperty.kt"); + } + + @TestMetadata("compiler/testData/codegen/boxInline/callableReference/bound") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Bound extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInBound() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("classProperty.kt") + public void testClassProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/classProperty.kt"); + } + + @TestMetadata("emptyLhsFunction.kt") + public void testEmptyLhsFunction() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/emptyLhsFunction.kt"); + } + + @TestMetadata("emptyLhsOnInlineProperty.kt") + public void testEmptyLhsOnInlineProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/emptyLhsOnInlineProperty.kt"); + } + + @TestMetadata("emptyLhsProperty.kt") + public void testEmptyLhsProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/emptyLhsProperty.kt"); + } + + @TestMetadata("expression.kt") + public void testExpression() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/expression.kt"); + } + + @TestMetadata("extensionReceiver.kt") + public void testExtensionReceiver() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/extensionReceiver.kt"); + } + + @TestMetadata("filter.kt") + public void testFilter() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/filter.kt"); + } + + @TestMetadata("inlineValueParameterInsteadOfReceiver.kt") + public void testInlineValueParameterInsteadOfReceiver() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/inlineValueParameterInsteadOfReceiver.kt"); + } + + @TestMetadata("innerGenericConstuctor.kt") + public void testInnerGenericConstuctor() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/innerGenericConstuctor.kt"); + } + + @TestMetadata("intrinsic.kt") + public void testIntrinsic() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/intrinsic.kt"); + } + + @TestMetadata("jvmFieldProperty.kt") + public void testJvmFieldProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/jvmFieldProperty.kt"); + } + + @TestMetadata("kt18728.kt") + public void testKt18728() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/kt18728.kt"); + } + + @TestMetadata("kt18728_2.kt") + public void testKt18728_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/kt18728_2.kt"); + } + + @TestMetadata("kt18728_3.kt") + public void testKt18728_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/kt18728_3.kt"); + } + + @TestMetadata("kt18728_4.kt") + public void testKt18728_4() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/kt18728_4.kt"); + } + + @TestMetadata("map.kt") + public void testMap() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/map.kt"); + } + + @TestMetadata("mixed.kt") + public void testMixed() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/mixed.kt"); + } + + @TestMetadata("objectProperty.kt") + public void testObjectProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/objectProperty.kt"); + } + + @TestMetadata("propertyImportedFromObject.kt") + public void testPropertyImportedFromObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/propertyImportedFromObject.kt"); + } + + @TestMetadata("sideEffect.kt") + public void testSideEffect() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/sideEffect.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/simple.kt"); + } + + @TestMetadata("simpleVal.kt") + public void testSimpleVal() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/simpleVal.kt"); + } + + @TestMetadata("simpleVal2.kt") + public void testSimpleVal2() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/simpleVal2.kt"); + } + + @TestMetadata("topLevelExtensionProperty.kt") + public void testTopLevelExtensionProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/topLevelExtensionProperty.kt"); + } + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/capture") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Capture extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInCapture() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/capture"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("captureInlinable.kt") + public void testCaptureInlinable() throws Exception { + runTest("compiler/testData/codegen/boxInline/capture/captureInlinable.kt"); + } + + @TestMetadata("captureInlinableAndOther.kt") + public void testCaptureInlinableAndOther() throws Exception { + runTest("compiler/testData/codegen/boxInline/capture/captureInlinableAndOther.kt"); + } + + @TestMetadata("captureThisAndReceiver.kt") + public void testCaptureThisAndReceiver() throws Exception { + runTest("compiler/testData/codegen/boxInline/capture/captureThisAndReceiver.kt"); + } + + @TestMetadata("generics.kt") + public void testGenerics() throws Exception { + runTest("compiler/testData/codegen/boxInline/capture/generics.kt"); + } + + @TestMetadata("simpleCapturingInClass.kt") + public void testSimpleCapturingInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/capture/simpleCapturingInClass.kt"); + } + + @TestMetadata("simpleCapturingInPackage.kt") + public void testSimpleCapturingInPackage() throws Exception { + runTest("compiler/testData/codegen/boxInline/capture/simpleCapturingInPackage.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/complex") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Complex extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInComplex() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("closureChain.kt") + public void testClosureChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/complex/closureChain.kt"); + } + + @TestMetadata("forEachLine.kt") + public void testForEachLine() throws Exception { + runTest("compiler/testData/codegen/boxInline/complex/forEachLine.kt"); + } + + @TestMetadata("lambdaInLambda.kt") + public void testLambdaInLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/complex/lambdaInLambda.kt"); + } + + @TestMetadata("swapAndWith.kt") + public void testSwapAndWith() throws Exception { + runTest("compiler/testData/codegen/boxInline/complex/swapAndWith.kt"); + } + + @TestMetadata("swapAndWith2.kt") + public void testSwapAndWith2() throws Exception { + runTest("compiler/testData/codegen/boxInline/complex/swapAndWith2.kt"); + } + + @TestMetadata("use.kt") + public void testUse() throws Exception { + runTest("compiler/testData/codegen/boxInline/complex/use.kt"); + } + + @TestMetadata("with.kt") + public void testWith() throws Exception { + runTest("compiler/testData/codegen/boxInline/complex/with.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/complexStack") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ComplexStack extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInComplexStack() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complexStack"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("asCheck.kt") + public void testAsCheck() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/asCheck.kt"); + } + + @TestMetadata("asCheck2.kt") + public void testAsCheck2() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/asCheck2.kt"); + } + + @TestMetadata("breakContinueInInlineLambdaArgument.kt") + public void testBreakContinueInInlineLambdaArgument() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/breakContinueInInlineLambdaArgument.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/simple.kt"); + } + + @TestMetadata("simple2.kt") + public void testSimple2() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/simple2.kt"); + } + + @TestMetadata("simple3.kt") + public void testSimple3() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/simple3.kt"); + } + + @TestMetadata("simple4.kt") + public void testSimple4() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/simple4.kt"); + } + + @TestMetadata("simpleExtension.kt") + public void testSimpleExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/simpleExtension.kt"); + } + + @TestMetadata("spillConstructorArgumentsAndInlineLambdaParameter.kt") + public void testSpillConstructorArgumentsAndInlineLambdaParameter() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/spillConstructorArgumentsAndInlineLambdaParameter.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/contracts") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Contracts extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInContracts() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("cfgDependendValInitialization.kt") + public void testCfgDependendValInitialization() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/cfgDependendValInitialization.kt"); + } + + @TestMetadata("complexInitializer.kt") + public void testComplexInitializer() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/complexInitializer.kt"); + } + + @TestMetadata("complexInitializerWithStackTransformation.kt") + public void testComplexInitializerWithStackTransformation() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/complexInitializerWithStackTransformation.kt"); + } + + @TestMetadata("crossinlineCallableReference.kt") + public void testCrossinlineCallableReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/crossinlineCallableReference.kt"); + } + + @TestMetadata("definiteLongValInitialization.kt") + public void testDefiniteLongValInitialization() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/definiteLongValInitialization.kt"); + } + + @TestMetadata("definiteNestedValInitialization.kt") + public void testDefiniteNestedValInitialization() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/definiteNestedValInitialization.kt"); + } + + @TestMetadata("definiteValInitInInitializer.kt") + public void testDefiniteValInitInInitializer() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/definiteValInitInInitializer.kt"); + } + + @TestMetadata("definiteValInitialization.kt") + public void testDefiniteValInitialization() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/definiteValInitialization.kt"); + } + + @TestMetadata("exactlyOnceCrossinline.kt") + public void testExactlyOnceCrossinline() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/exactlyOnceCrossinline.kt"); + } + + @TestMetadata("exactlyOnceCrossinline2.kt") + public void testExactlyOnceCrossinline2() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/exactlyOnceCrossinline2.kt"); + } + + @TestMetadata("exactlyOnceNoinline.kt") + public void testExactlyOnceNoinline() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/exactlyOnceNoinline.kt"); + } + + @TestMetadata("nonLocalReturn.kt") + public void testNonLocalReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/nonLocalReturn.kt"); + } + + @TestMetadata("nonLocalReturnWithCycle.kt") + public void testNonLocalReturnWithCycle() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/nonLocalReturnWithCycle.kt"); + } + + @TestMetadata("propertyInitialization.kt") + public void testPropertyInitialization() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/propertyInitialization.kt"); + } + + @TestMetadata("valInitializationAndUsageInNestedLambda.kt") + public void testValInitializationAndUsageInNestedLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/valInitializationAndUsageInNestedLambda.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/defaultValues") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DefaultValues extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + @TestMetadata("33Parameters.kt") + public void test33Parameters() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/33Parameters.kt"); + } + + @TestMetadata("33ParametersInConstructor.kt") + public void test33ParametersInConstructor() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/33ParametersInConstructor.kt"); + } + + public void testAllFilesPresentInDefaultValues() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("defaultInExtension.kt") + public void testDefaultInExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/defaultInExtension.kt"); + } + + @TestMetadata("defaultMethod.kt") + public void testDefaultMethod() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/defaultMethod.kt"); + } + + @TestMetadata("defaultMethodInClass.kt") + public void testDefaultMethodInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/defaultMethodInClass.kt"); + } + + @TestMetadata("defaultParamRemapping.kt") + public void testDefaultParamRemapping() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/defaultParamRemapping.kt"); + } + + @TestMetadata("inlineInDefaultParameter.kt") + public void testInlineInDefaultParameter() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/inlineInDefaultParameter.kt"); + } + + @TestMetadata("inlineLambdaInNoInlineDefault.kt") + public void testInlineLambdaInNoInlineDefault() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/inlineLambdaInNoInlineDefault.kt"); + } + + @TestMetadata("kt11479.kt") + public void testKt11479() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt11479.kt"); + } + + @TestMetadata("kt11479InlinedDefaultParameter.kt") + public void testKt11479InlinedDefaultParameter() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt11479InlinedDefaultParameter.kt"); + } + + @TestMetadata("kt14564.kt") + public void testKt14564() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt14564.kt"); + } + + @TestMetadata("kt14564_2.kt") + public void testKt14564_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt14564_2.kt"); + } + + @TestMetadata("kt16496.kt") + public void testKt16496() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt16496.kt"); + } + + @TestMetadata("kt18689.kt") + public void testKt18689() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt18689.kt"); + } + + @TestMetadata("kt18689_2.kt") + public void testKt18689_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt18689_2.kt"); + } + + @TestMetadata("kt18689_3.kt") + public void testKt18689_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt18689_3.kt"); + } + + @TestMetadata("kt18689_4.kt") + public void testKt18689_4() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt18689_4.kt"); + } + + @TestMetadata("kt5685.kt") + public void testKt5685() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt5685.kt"); + } + + @TestMetadata("simpleDefaultMethod.kt") + public void testSimpleDefaultMethod() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/simpleDefaultMethod.kt"); + } + + @TestMetadata("varArgNoInline.kt") + public void testVarArgNoInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/varArgNoInline.kt"); + } + + @TestMetadata("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class LambdaInlining extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInLambdaInlining() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("checkLambdaClassIsPresent.kt") + public void testCheckLambdaClassIsPresent() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/checkLambdaClassIsPresent.kt"); + } + + @TestMetadata("checkLambdaClassesArePresent.kt") + public void testCheckLambdaClassesArePresent() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/checkLambdaClassesArePresent.kt"); + } + + @TestMetadata("checkObjectClassIsPresent.kt") + public void testCheckObjectClassIsPresent() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/checkObjectClassIsPresent.kt"); + } + + @TestMetadata("checkStaticLambdaClassIsPresent.kt") + public void testCheckStaticLambdaClassIsPresent() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/checkStaticLambdaClassIsPresent.kt"); + } + + @TestMetadata("checkStaticLambdaClassesArePresent.kt") + public void testCheckStaticLambdaClassesArePresent() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/checkStaticLambdaClassesArePresent.kt"); + } + + @TestMetadata("checkStaticObjectClassIsPresent.kt") + public void testCheckStaticObjectClassIsPresent() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/checkStaticObjectClassIsPresent.kt"); + } + + @TestMetadata("defaultCallInDefaultLambda.kt") + public void testDefaultCallInDefaultLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/defaultCallInDefaultLambda.kt"); + } + + @TestMetadata("defaultLambdaInNoInline.kt") + public void testDefaultLambdaInNoInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/defaultLambdaInNoInline.kt"); + } + + @TestMetadata("differentInvokeSignature.kt") + public void testDifferentInvokeSignature() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/differentInvokeSignature.kt"); + } + + @TestMetadata("genericLambda.kt") + public void testGenericLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/genericLambda.kt"); + } + + @TestMetadata("instanceCapturedInClass.kt") + public void testInstanceCapturedInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/instanceCapturedInClass.kt"); + } + + @TestMetadata("instanceCapturedInInterface.kt") + public void testInstanceCapturedInInterface() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/instanceCapturedInInterface.kt"); + } + + @TestMetadata("jvmStaticDefault.kt") + public void testJvmStaticDefault() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/jvmStaticDefault.kt"); + } + + @TestMetadata("kt21827.kt") + public void testKt21827() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/kt21827.kt"); + } + + @TestMetadata("kt21946.kt") + public void testKt21946() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/kt21946.kt"); + } + + @TestMetadata("kt24477.kt") + public void testKt24477() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/kt24477.kt"); + } + + @TestMetadata("kt25106.kt") + public void testKt25106() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/kt25106.kt"); + } + + @TestMetadata("kt26636.kt") + public void testKt26636() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/kt26636.kt"); + } + + @TestMetadata("noInline.kt") + public void testNoInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/noInline.kt"); + } + + @TestMetadata("nonDefaultInlineInNoInline.kt") + public void testNonDefaultInlineInNoInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/nonDefaultInlineInNoInline.kt"); + } + + @TestMetadata("receiverClash.kt") + public void testReceiverClash() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/receiverClash.kt"); + } + + @TestMetadata("receiverClash2.kt") + public void testReceiverClash2() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/receiverClash2.kt"); + } + + @TestMetadata("receiverClashInClass.kt") + public void testReceiverClashInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/receiverClashInClass.kt"); + } + + @TestMetadata("receiverClashInClass2.kt") + public void testReceiverClashInClass2() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/receiverClashInClass2.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/simple.kt"); + } + + @TestMetadata("simpleErased.kt") + public void testSimpleErased() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/simpleErased.kt"); + } + + @TestMetadata("simpleErasedStaticInstance.kt") + public void testSimpleErasedStaticInstance() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/simpleErasedStaticInstance.kt"); + } + + @TestMetadata("simpleExtension.kt") + public void testSimpleExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/simpleExtension.kt"); + } + + @TestMetadata("simpleGeneric.kt") + public void testSimpleGeneric() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/simpleGeneric.kt"); + } + + @TestMetadata("simpleStaticInstance.kt") + public void testSimpleStaticInstance() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/simpleStaticInstance.kt"); + } + + @TestMetadata("thisClash.kt") + public void testThisClash() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/thisClash.kt"); + } + + @TestMetadata("thisClashInClass.kt") + public void testThisClashInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/thisClashInClass.kt"); + } + + @TestMetadata("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CallableReferences extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInCallableReferences() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("boundFunctionReference.kt") + public void testBoundFunctionReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundFunctionReference.kt"); + } + + @TestMetadata("boundFunctionReferenceOnInt.kt") + public void testBoundFunctionReferenceOnInt() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundFunctionReferenceOnInt.kt"); + } + + @TestMetadata("boundFunctionReferenceOnLong.kt") + public void testBoundFunctionReferenceOnLong() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundFunctionReferenceOnLong.kt"); + } + + @TestMetadata("boundPropertyReference.kt") + public void testBoundPropertyReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundPropertyReference.kt"); + } + + @TestMetadata("boundPropertyReferenceOnInt.kt") + public void testBoundPropertyReferenceOnInt() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundPropertyReferenceOnInt.kt"); + } + + @TestMetadata("boundPropertyReferenceOnLong.kt") + public void testBoundPropertyReferenceOnLong() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundPropertyReferenceOnLong.kt"); + } + + @TestMetadata("constuctorReference.kt") + public void testConstuctorReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/constuctorReference.kt"); + } + + @TestMetadata("differentInvokeSignature.kt") + public void testDifferentInvokeSignature() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/differentInvokeSignature.kt"); + } + + @TestMetadata("differentInvokeSignature2.kt") + public void testDifferentInvokeSignature2() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/differentInvokeSignature2.kt"); + } + + @TestMetadata("functionImportedFromObject.kt") + public void testFunctionImportedFromObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/functionImportedFromObject.kt"); + } + + @TestMetadata("functionReference.kt") + public void testFunctionReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/functionReference.kt"); + } + + @TestMetadata("functionReferenceFromClass.kt") + public void testFunctionReferenceFromClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/functionReferenceFromClass.kt"); + } + + @TestMetadata("functionReferenceFromObject.kt") + public void testFunctionReferenceFromObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/functionReferenceFromObject.kt"); + } + + @TestMetadata("innerClassConstuctorReference.kt") + public void testInnerClassConstuctorReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/innerClassConstuctorReference.kt"); + } + + @TestMetadata("mutableBoundPropertyReferenceFromClass.kt") + public void testMutableBoundPropertyReferenceFromClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/mutableBoundPropertyReferenceFromClass.kt"); + } + + @TestMetadata("mutablePropertyReferenceFromClass.kt") + public void testMutablePropertyReferenceFromClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/mutablePropertyReferenceFromClass.kt"); + } + + @TestMetadata("privateFunctionReference.kt") + public void testPrivateFunctionReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/privateFunctionReference.kt"); + } + + @TestMetadata("privatePropertyReference.kt") + public void testPrivatePropertyReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/privatePropertyReference.kt"); + } + + @TestMetadata("propertyImportedFromObject.kt") + public void testPropertyImportedFromObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/propertyImportedFromObject.kt"); + } + + @TestMetadata("propertyReference.kt") + public void testPropertyReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/propertyReference.kt"); + } + + @TestMetadata("propertyReferenceFromClass.kt") + public void testPropertyReferenceFromClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/propertyReferenceFromClass.kt"); + } + + @TestMetadata("propertyReferenceFromObject.kt") + public void testPropertyReferenceFromObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/propertyReferenceFromObject.kt"); + } + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/defaultValues/maskElimination") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MaskElimination extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + @TestMetadata("32Parameters.kt") + public void test32Parameters() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/32Parameters.kt"); + } + + @TestMetadata("33Parameters.kt") + public void test33Parameters() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/33Parameters.kt"); + } + + public void testAllFilesPresentInMaskElimination() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/maskElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("kt18792.kt") + public void testKt18792() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/kt18792.kt"); + } + + @TestMetadata("kt19679.kt") + public void testKt19679() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/kt19679.kt"); + } + + @TestMetadata("kt19679_2.kt") + public void testKt19679_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/kt19679_2.kt"); + } + + @TestMetadata("kt19679_3.kt") + public void testKt19679_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/kt19679_3.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/simple.kt"); + } + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/delegatedProperty") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DelegatedProperty extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInDelegatedProperty() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("kt16864.kt") + public void testKt16864() throws Exception { + runTest("compiler/testData/codegen/boxInline/delegatedProperty/kt16864.kt"); + } + + @TestMetadata("local.kt") + public void testLocal() throws Exception { + runTest("compiler/testData/codegen/boxInline/delegatedProperty/local.kt"); + } + + @TestMetadata("localInAnonymousObject.kt") + public void testLocalInAnonymousObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/delegatedProperty/localInAnonymousObject.kt"); + } + + @TestMetadata("localInLambda.kt") + public void testLocalInLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/delegatedProperty/localInLambda.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/enclosingInfo") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class EnclosingInfo extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInEnclosingInfo() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("anonymousInLambda.kt") + public void testAnonymousInLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/enclosingInfo/anonymousInLambda.kt"); + } + + @TestMetadata("inlineChain.kt") + public void testInlineChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/enclosingInfo/inlineChain.kt"); + } + + @TestMetadata("inlineChain2.kt") + public void testInlineChain2() throws Exception { + runTest("compiler/testData/codegen/boxInline/enclosingInfo/inlineChain2.kt"); + } + + @TestMetadata("objectInInlineFun.kt") + public void testObjectInInlineFun() throws Exception { + runTest("compiler/testData/codegen/boxInline/enclosingInfo/objectInInlineFun.kt"); + } + + @TestMetadata("transformedConstructor.kt") + public void testTransformedConstructor() throws Exception { + runTest("compiler/testData/codegen/boxInline/enclosingInfo/transformedConstructor.kt"); + } + + @TestMetadata("transformedConstructorWithAdditionalObject.kt") + public void testTransformedConstructorWithAdditionalObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/enclosingInfo/transformedConstructorWithAdditionalObject.kt"); + } + + @TestMetadata("transformedConstructorWithNestedInline.kt") + public void testTransformedConstructorWithNestedInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/enclosingInfo/transformedConstructorWithNestedInline.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/enum") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Enum extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInEnum() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("kt10569.kt") + public void testKt10569() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/kt10569.kt"); + } + + @TestMetadata("kt18254.kt") + public void testKt18254() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/kt18254.kt"); + } + + @TestMetadata("valueOf.kt") + public void testValueOf() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valueOf.kt"); + } + + @TestMetadata("valueOfCapturedType.kt") + public void testValueOfCapturedType() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valueOfCapturedType.kt"); + } + + @TestMetadata("valueOfChain.kt") + public void testValueOfChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valueOfChain.kt"); + } + + @TestMetadata("valueOfChainCapturedType.kt") + public void testValueOfChainCapturedType() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valueOfChainCapturedType.kt"); + } + + @TestMetadata("valueOfNonReified.kt") + public void testValueOfNonReified() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valueOfNonReified.kt"); + } + + @TestMetadata("values.kt") + public void testValues() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/values.kt"); + } + + @TestMetadata("valuesAsArray.kt") + public void testValuesAsArray() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valuesAsArray.kt"); + } + + @TestMetadata("valuesCapturedType.kt") + public void testValuesCapturedType() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valuesCapturedType.kt"); + } + + @TestMetadata("valuesChain.kt") + public void testValuesChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valuesChain.kt"); + } + + @TestMetadata("valuesChainCapturedType.kt") + public void testValuesChainCapturedType() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valuesChainCapturedType.kt"); + } + + @TestMetadata("valuesNonReified.kt") + public void testValuesNonReified() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valuesNonReified.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/functionExpression") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class FunctionExpression extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInFunctionExpression() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("extension.kt") + public void testExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/functionExpression/extension.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/inlineClasses") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineClasses extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInInlineClasses() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("inlineClassWithInlineValReturningInlineClass.kt") + public void testInlineClassWithInlineValReturningInlineClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/inlineClassWithInlineValReturningInlineClass.kt"); + } + + @TestMetadata("inlineFunctionInsideInlineClassesBox.kt") + public void testInlineFunctionInsideInlineClassesBox() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/inlineFunctionInsideInlineClassesBox.kt"); + } + + @TestMetadata("noReturnTypeManglingFun.kt") + public void testNoReturnTypeManglingFun() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/noReturnTypeManglingFun.kt"); + } + + @TestMetadata("noReturnTypeManglingFunJvmName.kt") + public void testNoReturnTypeManglingFunJvmName() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/noReturnTypeManglingFunJvmName.kt"); + } + + @TestMetadata("noReturnTypeManglingVal.kt") + public void testNoReturnTypeManglingVal() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/noReturnTypeManglingVal.kt"); + } + + @TestMetadata("withReturnTypeManglingFun.kt") + public void testWithReturnTypeManglingFun() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/withReturnTypeManglingFun.kt"); + } + + @TestMetadata("withReturnTypeManglingFunJvmName.kt") + public void testWithReturnTypeManglingFunJvmName() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/withReturnTypeManglingFunJvmName.kt"); + } + + @TestMetadata("withReturnTypeManglingVal.kt") + public void testWithReturnTypeManglingVal() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/withReturnTypeManglingVal.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/innerClasses") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InnerClasses extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInInnerClasses() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("captureThisAndOuter.kt") + public void testCaptureThisAndOuter() throws Exception { + runTest("compiler/testData/codegen/boxInline/innerClasses/captureThisAndOuter.kt"); + } + + @TestMetadata("innerLambda.kt") + public void testInnerLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/innerClasses/innerLambda.kt"); + } + + @TestMetadata("kt10259.kt") + public void testKt10259() throws Exception { + runTest("compiler/testData/codegen/boxInline/innerClasses/kt10259.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/jvmPackageName") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JvmPackageName extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInJvmPackageName() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/jvmPackageName/simple.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/lambdaClassClash") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class LambdaClassClash extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInLambdaClassClash() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaClassClash"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("lambdaClassClash.kt") + public void testLambdaClassClash() throws Exception { + runTest("compiler/testData/codegen/boxInline/lambdaClassClash/lambdaClassClash.kt"); + } + + @TestMetadata("noInlineLambdaX2.kt") + public void testNoInlineLambdaX2() throws Exception { + runTest("compiler/testData/codegen/boxInline/lambdaClassClash/noInlineLambdaX2.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/lambdaTransformation") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class LambdaTransformation extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInLambdaTransformation() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaTransformation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("lambdaCloning.kt") + public void testLambdaCloning() throws Exception { + runTest("compiler/testData/codegen/boxInline/lambdaTransformation/lambdaCloning.kt"); + } + + @TestMetadata("lambdaInLambda2.kt") + public void testLambdaInLambda2() throws Exception { + runTest("compiler/testData/codegen/boxInline/lambdaTransformation/lambdaInLambda2.kt"); + } + + @TestMetadata("lambdaInLambdaNoInline.kt") + public void testLambdaInLambdaNoInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/lambdaTransformation/lambdaInLambdaNoInline.kt"); + } + + @TestMetadata("regeneratedLambdaName.kt") + public void testRegeneratedLambdaName() throws Exception { + runTest("compiler/testData/codegen/boxInline/lambdaTransformation/regeneratedLambdaName.kt"); + } + + @TestMetadata("regeneratedLambdaName2.kt") + public void testRegeneratedLambdaName2() throws Exception { + runTest("compiler/testData/codegen/boxInline/lambdaTransformation/regeneratedLambdaName2.kt"); + } + + @TestMetadata("sameCaptured.kt") + public void testSameCaptured() throws Exception { + runTest("compiler/testData/codegen/boxInline/lambdaTransformation/sameCaptured.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/localFunInLambda") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class LocalFunInLambda extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInLocalFunInLambda() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/localFunInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("defaultParam.kt") + public void testDefaultParam() throws Exception { + runTest("compiler/testData/codegen/boxInline/localFunInLambda/defaultParam.kt"); + } + + @TestMetadata("lambdaInLambdaCapturesAnotherFun.kt") + public void testLambdaInLambdaCapturesAnotherFun() throws Exception { + runTest("compiler/testData/codegen/boxInline/localFunInLambda/lambdaInLambdaCapturesAnotherFun.kt"); + } + + @TestMetadata("localFunInLambda.kt") + public void testLocalFunInLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/localFunInLambda/localFunInLambda.kt"); + } + + @TestMetadata("localFunInLambdaCapturesAnotherFun.kt") + public void testLocalFunInLambdaCapturesAnotherFun() throws Exception { + runTest("compiler/testData/codegen/boxInline/localFunInLambda/localFunInLambdaCapturesAnotherFun.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/multiModule") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultiModule extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInMultiModule() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("tryCatchWithRecursiveInline.kt") + public void testTryCatchWithRecursiveInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/multiModule/tryCatchWithRecursiveInline.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/multifileClasses") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifileClasses extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInMultifileClasses() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("defaultArguments.kt") + public void testDefaultArguments() throws Exception { + runTest("compiler/testData/codegen/boxInline/multifileClasses/defaultArguments.kt"); + } + + @TestMetadata("inlineFromOptimizedMultifileClass.kt") + public void testInlineFromOptimizedMultifileClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/multifileClasses/inlineFromOptimizedMultifileClass.kt"); + } + + @TestMetadata("inlineFromOtherPackage.kt") + public void testInlineFromOtherPackage() throws Exception { + runTest("compiler/testData/codegen/boxInline/multifileClasses/inlineFromOtherPackage.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/multiplatform") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Multiplatform extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInMultiplatform() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("compiler/testData/codegen/boxInline/multiplatform/defaultArguments") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DefaultArguments extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInDefaultArguments() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("receiversAndParametersInLambda.kt") + public void testReceiversAndParametersInLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/multiplatform/defaultArguments/receiversAndParametersInLambda.kt"); + } + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/noInline") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NoInline extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInNoInline() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/noInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("extensionReceiver.kt") + public void testExtensionReceiver() throws Exception { + runTest("compiler/testData/codegen/boxInline/noInline/extensionReceiver.kt"); + } + + @TestMetadata("lambdaAsGeneric.kt") + public void testLambdaAsGeneric() throws Exception { + runTest("compiler/testData/codegen/boxInline/noInline/lambdaAsGeneric.kt"); + } + + @TestMetadata("lambdaAsNonFunction.kt") + public void testLambdaAsNonFunction() throws Exception { + runTest("compiler/testData/codegen/boxInline/noInline/lambdaAsNonFunction.kt"); + } + + @TestMetadata("noInline.kt") + public void testNoInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/noInline/noInline.kt"); + } + + @TestMetadata("noInlineLambdaChain.kt") + public void testNoInlineLambdaChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/noInline/noInlineLambdaChain.kt"); + } + + @TestMetadata("noInlineLambdaChainWithCapturedInline.kt") + public void testNoInlineLambdaChainWithCapturedInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/noInline/noInlineLambdaChainWithCapturedInline.kt"); + } + + @TestMetadata("withoutInline.kt") + public void testWithoutInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/noInline/withoutInline.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NonLocalReturns extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInNonLocalReturns() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("explicitLocalReturn.kt") + public void testExplicitLocalReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/explicitLocalReturn.kt"); + } + + @TestMetadata("fromInterfaceDefaultGetter.kt") + public void testFromInterfaceDefaultGetter() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/fromInterfaceDefaultGetter.kt"); + } + + @TestMetadata("justReturnInLambda.kt") + public void testJustReturnInLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/justReturnInLambda.kt"); + } + + @TestMetadata("kt5199.kt") + public void testKt5199() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/kt5199.kt"); + } + + @TestMetadata("kt8948.kt") + public void testKt8948() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/kt8948.kt"); + } + + @TestMetadata("kt8948v2.kt") + public void testKt8948v2() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/kt8948v2.kt"); + } + + @TestMetadata("nestedNonLocals.kt") + public void testNestedNonLocals() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/nestedNonLocals.kt"); + } + + @TestMetadata("noInlineLocalReturn.kt") + public void testNoInlineLocalReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/noInlineLocalReturn.kt"); + } + + @TestMetadata("nonLocalReturnFromOuterLambda.kt") + public void testNonLocalReturnFromOuterLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/nonLocalReturnFromOuterLambda.kt"); + } + + @TestMetadata("propertyAccessors.kt") + public void testPropertyAccessors() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/propertyAccessors.kt"); + } + + @TestMetadata("returnFromFunctionExpr.kt") + public void testReturnFromFunctionExpr() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/returnFromFunctionExpr.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/simple.kt"); + } + + @TestMetadata("simpleFunctional.kt") + public void testSimpleFunctional() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/simpleFunctional.kt"); + } + + @TestMetadata("simpleVoid.kt") + public void testSimpleVoid() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/simpleVoid.kt"); + } + + @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Deparenthesize extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInDeparenthesize() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("bracket.kt") + public void testBracket() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize/bracket.kt"); + } + + @TestMetadata("labeled.kt") + public void testLabeled() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize/labeled.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TryFinally extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInTryFinally() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("kt16417.kt") + public void testKt16417() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt16417.kt"); + } + + @TestMetadata("kt20433.kt") + public void testKt20433() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt20433.kt"); + } + + @TestMetadata("kt20433_2.kt") + public void testKt20433_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt20433_2.kt"); + } + + @TestMetadata("kt20433_2_void.kt") + public void testKt20433_2_void() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt20433_2_void.kt"); + } + + @TestMetadata("kt20433_void.kt") + public void testKt20433_void() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt20433_void.kt"); + } + + @TestMetadata("kt26384.kt") + public void testKt26384() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt26384.kt"); + } + + @TestMetadata("kt26384_2.kt") + public void testKt26384_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt26384_2.kt"); + } + + @TestMetadata("kt28546.kt") + public void testKt28546() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt28546.kt"); + } + + @TestMetadata("kt6956.kt") + public void testKt6956() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt6956.kt"); + } + + @TestMetadata("kt7273.kt") + public void testKt7273() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt7273.kt"); + } + + @TestMetadata("nonLocalReturnFromCatchBlock.kt") + public void testNonLocalReturnFromCatchBlock() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/nonLocalReturnFromCatchBlock.kt"); + } + + @TestMetadata("nonLocalReturnFromOuterLambda.kt") + public void testNonLocalReturnFromOuterLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/nonLocalReturnFromOuterLambda.kt"); + } + + @TestMetadata("nonLocalReturnToCatchBlock.kt") + public void testNonLocalReturnToCatchBlock() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/nonLocalReturnToCatchBlock.kt"); + } + + @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CallSite extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInCallSite() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("callSite.kt") + public void testCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite/callSite.kt"); + } + + @TestMetadata("callSiteComplex.kt") + public void testCallSiteComplex() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite/callSiteComplex.kt"); + } + + @TestMetadata("exceptionTableSplit.kt") + public void testExceptionTableSplit() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite/exceptionTableSplit.kt"); + } + + @TestMetadata("exceptionTableSplitNoReturn.kt") + public void testExceptionTableSplitNoReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite/exceptionTableSplitNoReturn.kt"); + } + + @TestMetadata("finallyInFinally.kt") + public void testFinallyInFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite/finallyInFinally.kt"); + } + + @TestMetadata("wrongVarInterval.kt") + public void testWrongVarInterval() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite/wrongVarInterval.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Chained extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInChained() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("finallyInFinally.kt") + public void testFinallyInFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/finallyInFinally.kt"); + } + + @TestMetadata("finallyInFinally2.kt") + public void testFinallyInFinally2() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/finallyInFinally2.kt"); + } + + @TestMetadata("intReturn.kt") + public void testIntReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/intReturn.kt"); + } + + @TestMetadata("intReturnComplex.kt") + public void testIntReturnComplex() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/intReturnComplex.kt"); + } + + @TestMetadata("intReturnComplex2.kt") + public void testIntReturnComplex2() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/intReturnComplex2.kt"); + } + + @TestMetadata("intReturnComplex3.kt") + public void testIntReturnComplex3() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/intReturnComplex3.kt"); + } + + @TestMetadata("intReturnComplex4.kt") + public void testIntReturnComplex4() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/intReturnComplex4.kt"); + } + + @TestMetadata("nestedLambda.kt") + public void testNestedLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/nestedLambda.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DeclSite extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInDeclSite() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("complex.kt") + public void testComplex() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/complex.kt"); + } + + @TestMetadata("intReturn.kt") + public void testIntReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/intReturn.kt"); + } + + @TestMetadata("intReturnComplex.kt") + public void testIntReturnComplex() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/intReturnComplex.kt"); + } + + @TestMetadata("longReturn.kt") + public void testLongReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/longReturn.kt"); + } + + @TestMetadata("nested.kt") + public void testNested() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/nested.kt"); + } + + @TestMetadata("returnInFinally.kt") + public void testReturnInFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/returnInFinally.kt"); + } + + @TestMetadata("returnInTry.kt") + public void testReturnInTry() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/returnInTry.kt"); + } + + @TestMetadata("returnInTryAndFinally.kt") + public void testReturnInTryAndFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/returnInTryAndFinally.kt"); + } + + @TestMetadata("severalInTry.kt") + public void testSeveralInTry() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/severalInTry.kt"); + } + + @TestMetadata("severalInTryComplex.kt") + public void testSeveralInTryComplex() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/severalInTryComplex.kt"); + } + + @TestMetadata("voidInlineFun.kt") + public void testVoidInlineFun() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/voidInlineFun.kt"); + } + + @TestMetadata("voidNonLocal.kt") + public void testVoidNonLocal() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/voidNonLocal.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ExceptionTable extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInExceptionTable() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("break.kt") + public void testBreak() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/break.kt"); + } + + @TestMetadata("continue.kt") + public void testContinue() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/continue.kt"); + } + + @TestMetadata("exceptionInFinally.kt") + public void testExceptionInFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/exceptionInFinally.kt"); + } + + @TestMetadata("forInFinally.kt") + public void testForInFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/forInFinally.kt"); + } + + @TestMetadata("innerAndExternal.kt") + public void testInnerAndExternal() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/innerAndExternal.kt"); + } + + @TestMetadata("innerAndExternalNested.kt") + public void testInnerAndExternalNested() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/innerAndExternalNested.kt"); + } + + @TestMetadata("innerAndExternalSimple.kt") + public void testInnerAndExternalSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/innerAndExternalSimple.kt"); + } + + @TestMetadata("kt31653.kt") + public void testKt31653() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/kt31653.kt"); + } + + @TestMetadata("kt31653_2.kt") + public void testKt31653_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/kt31653_2.kt"); + } + + @TestMetadata("kt31923.kt") + public void testKt31923() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/kt31923.kt"); + } + + @TestMetadata("kt31923_2.kt") + public void testKt31923_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/kt31923_2.kt"); + } + + @TestMetadata("kt31923_wrong.kt") + public void testKt31923_wrong() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/kt31923_wrong.kt"); + } + + @TestMetadata("nested.kt") + public void testNested() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/nested.kt"); + } + + @TestMetadata("nestedWithReturns.kt") + public void testNestedWithReturns() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/nestedWithReturns.kt"); + } + + @TestMetadata("nestedWithReturnsSimple.kt") + public void testNestedWithReturnsSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/nestedWithReturnsSimple.kt"); + } + + @TestMetadata("noFinally.kt") + public void testNoFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/noFinally.kt"); + } + + @TestMetadata("severalCatchClause.kt") + public void testSeveralCatchClause() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/severalCatchClause.kt"); + } + + @TestMetadata("simpleThrow.kt") + public void testSimpleThrow() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/simpleThrow.kt"); + } + + @TestMetadata("synchonized.kt") + public void testSynchonized() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/synchonized.kt"); + } + + @TestMetadata("throwInFinally.kt") + public void testThrowInFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/throwInFinally.kt"); + } + + @TestMetadata("tryCatchInFinally.kt") + public void testTryCatchInFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/tryCatchInFinally.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Variables extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInVariables() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("kt7792.kt") + public void testKt7792() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables/kt7792.kt"); + } + } + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/optimizations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Optimizations extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInOptimizations() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("kt20844.kt") + public void testKt20844() throws Exception { + runTest("compiler/testData/codegen/boxInline/optimizations/kt20844.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/private") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Private extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + @TestMetadata("accessorForConst.kt") + public void testAccessorForConst() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/accessorForConst.kt"); + } + + @TestMetadata("accessorStability.kt") + public void testAccessorStability() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/accessorStability.kt"); + } + + @TestMetadata("accessorStabilityInClass.kt") + public void testAccessorStabilityInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/accessorStabilityInClass.kt"); + } + + public void testAllFilesPresentInPrivate() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("effectivePrivate.kt") + public void testEffectivePrivate() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/effectivePrivate.kt"); + } + + @TestMetadata("kt6453.kt") + public void testKt6453() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/kt6453.kt"); + } + + @TestMetadata("kt8094.kt") + public void testKt8094() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/kt8094.kt"); + } + + @TestMetadata("kt8095.kt") + public void testKt8095() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/kt8095.kt"); + } + + @TestMetadata("nestedInPrivateClass.kt") + public void testNestedInPrivateClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/nestedInPrivateClass.kt"); + } + + @TestMetadata("privateClass.kt") + public void testPrivateClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/privateClass.kt"); + } + + @TestMetadata("privateClassExtensionLambda.kt") + public void testPrivateClassExtensionLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/privateClassExtensionLambda.kt"); + } + + @TestMetadata("privateInInlineInMultiFileFacade.kt") + public void testPrivateInInlineInMultiFileFacade() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/privateInInlineInMultiFileFacade.kt"); + } + + @TestMetadata("privateInline.kt") + public void testPrivateInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/privateInline.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/property") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Property extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInProperty() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("augAssignmentAndInc.kt") + public void testAugAssignmentAndInc() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/augAssignmentAndInc.kt"); + } + + @TestMetadata("augAssignmentAndIncInClass.kt") + public void testAugAssignmentAndIncInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/augAssignmentAndIncInClass.kt"); + } + + @TestMetadata("augAssignmentAndIncInClassViaConvention.kt") + public void testAugAssignmentAndIncInClassViaConvention() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/augAssignmentAndIncInClassViaConvention.kt"); + } + + @TestMetadata("augAssignmentAndIncOnExtension.kt") + public void testAugAssignmentAndIncOnExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/augAssignmentAndIncOnExtension.kt"); + } + + @TestMetadata("augAssignmentAndIncOnExtensionInClass.kt") + public void testAugAssignmentAndIncOnExtensionInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/augAssignmentAndIncOnExtensionInClass.kt"); + } + + @TestMetadata("augAssignmentAndIncViaConvention.kt") + public void testAugAssignmentAndIncViaConvention() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/augAssignmentAndIncViaConvention.kt"); + } + + @TestMetadata("fromObject.kt") + public void testFromObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/fromObject.kt"); + } + + @TestMetadata("kt22649.kt") + public void testKt22649() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/kt22649.kt"); + } + + @TestMetadata("property.kt") + public void testProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/property.kt"); + } + + @TestMetadata("reifiedVal.kt") + public void testReifiedVal() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/reifiedVal.kt"); + } + + @TestMetadata("reifiedVar.kt") + public void testReifiedVar() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/reifiedVar.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/simple.kt"); + } + + @TestMetadata("simpleExtension.kt") + public void testSimpleExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/simpleExtension.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/reified") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Reified extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInReified() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("arrayConstructor.kt") + public void testArrayConstructor() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/arrayConstructor.kt"); + } + + @TestMetadata("arrayOf.kt") + public void testArrayOf() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/arrayOf.kt"); + } + + @TestMetadata("capturedLambda.kt") + public void testCapturedLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/capturedLambda.kt"); + } + + @TestMetadata("capturedLambda2.kt") + public void testCapturedLambda2() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/capturedLambda2.kt"); + } + + @TestMetadata("kt11081.kt") + public void testKt11081() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt11081.kt"); + } + + @TestMetadata("kt11677.kt") + public void testKt11677() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt11677.kt"); + } + + @TestMetadata("kt15956.kt") + public void testKt15956() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt15956.kt"); + } + + @TestMetadata("kt15997.kt") + public void testKt15997() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt15997.kt"); + } + + @TestMetadata("kt15997_2.kt") + public void testKt15997_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt15997_2.kt"); + } + + @TestMetadata("kt18977.kt") + public void testKt18977() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt18977.kt"); + } + + @TestMetadata("kt6988.kt") + public void testKt6988() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt6988.kt"); + } + + @TestMetadata("kt6988_2.kt") + public void testKt6988_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt6988_2.kt"); + } + + @TestMetadata("kt6990.kt") + public void testKt6990() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt6990.kt"); + } + + @TestMetadata("kt7017.kt") + public void testKt7017() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt7017.kt"); + } + + @TestMetadata("kt8047.kt") + public void testKt8047() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt8047.kt"); + } + + @TestMetadata("kt8047_2.kt") + public void testKt8047_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt8047_2.kt"); + } + + @TestMetadata("kt9637.kt") + public void testKt9637() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt9637.kt"); + } + + @TestMetadata("kt9637_2.kt") + public void testKt9637_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt9637_2.kt"); + } + + @TestMetadata("nonCapturingObjectInLambda.kt") + public void testNonCapturingObjectInLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/nonCapturingObjectInLambda.kt"); + } + + @TestMetadata("packages.kt") + public void testPackages() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/packages.kt"); + } + + @TestMetadata("compiler/testData/codegen/boxInline/reified/checkCast") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CheckCast extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInCheckCast() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/checkCast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("chain.kt") + public void testChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/chain.kt"); + } + + @TestMetadata("kt26435.kt") + public void testKt26435() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/kt26435.kt"); + } + + @TestMetadata("kt26435_2.kt") + public void testKt26435_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/kt26435_2.kt"); + } + + @TestMetadata("kt26435_3.kt") + public void testKt26435_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/kt26435_3.kt"); + } + + @TestMetadata("kt8043.kt") + public void testKt8043() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/kt8043.kt"); + } + + @TestMetadata("maxStack.kt") + public void testMaxStack() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/maxStack.kt"); + } + + @TestMetadata("nullable.kt") + public void testNullable() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/nullable.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/simple.kt"); + } + + @TestMetadata("simpleSafe.kt") + public void testSimpleSafe() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/simpleSafe.kt"); + } + + @TestMetadata("simple_1_3.kt") + public void testSimple_1_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/simple_1_3.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/reified/defaultLambda") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DefaultLambda extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInDefaultLambda() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("chain.kt") + public void testChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/defaultLambda/chain.kt"); + } + + @TestMetadata("nested.kt") + public void testNested() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/defaultLambda/nested.kt"); + } + + @TestMetadata("nested2.kt") + public void testNested2() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/defaultLambda/nested2.kt"); + } + + @TestMetadata("nested2Static.kt") + public void testNested2Static() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/defaultLambda/nested2Static.kt"); + } + + @TestMetadata("nestedStatic.kt") + public void testNestedStatic() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/defaultLambda/nestedStatic.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/defaultLambda/simple.kt"); + } + + @TestMetadata("transitiveChain.kt") + public void testTransitiveChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/defaultLambda/transitiveChain.kt"); + } + + @TestMetadata("transitiveChainStatic.kt") + public void testTransitiveChainStatic() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/defaultLambda/transitiveChainStatic.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/reified/isCheck") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class IsCheck extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInIsCheck() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/isCheck"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("chain.kt") + public void testChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/isCheck/chain.kt"); + } + + @TestMetadata("nullable.kt") + public void testNullable() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/isCheck/nullable.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/isCheck/simple.kt"); + } + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/signature") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Signature extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInSignature() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("inProjectionSubstitution.kt") + public void testInProjectionSubstitution() throws Exception { + runTest("compiler/testData/codegen/boxInline/signature/inProjectionSubstitution.kt"); + } + + @TestMetadata("outProjectionSubstitution.kt") + public void testOutProjectionSubstitution() throws Exception { + runTest("compiler/testData/codegen/boxInline/signature/outProjectionSubstitution.kt"); + } + + @TestMetadata("recursion.kt") + public void testRecursion() throws Exception { + runTest("compiler/testData/codegen/boxInline/signature/recursion.kt"); + } + + @TestMetadata("sameFormalParameterName.kt") + public void testSameFormalParameterName() throws Exception { + runTest("compiler/testData/codegen/boxInline/signature/sameFormalParameterName.kt"); + } + + @TestMetadata("sameReifiedFormalParameterName.kt") + public void testSameReifiedFormalParameterName() throws Exception { + runTest("compiler/testData/codegen/boxInline/signature/sameReifiedFormalParameterName.kt"); + } + + @TestMetadata("starProjectionSubstitution.kt") + public void testStarProjectionSubstitution() throws Exception { + runTest("compiler/testData/codegen/boxInline/signature/starProjectionSubstitution.kt"); + } + + @TestMetadata("typeParameterInLambda.kt") + public void testTypeParameterInLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/signature/typeParameterInLambda.kt"); + } + + @TestMetadata("typeParametersSubstitution.kt") + public void testTypeParametersSubstitution() throws Exception { + runTest("compiler/testData/codegen/boxInline/signature/typeParametersSubstitution.kt"); + } + + @TestMetadata("typeParametersSubstitution2.kt") + public void testTypeParametersSubstitution2() throws Exception { + runTest("compiler/testData/codegen/boxInline/signature/typeParametersSubstitution2.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/simple") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Simple extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInSimple() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/simple"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("captureAndArgumentIncompatibleTypes.kt") + public void testCaptureAndArgumentIncompatibleTypes() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/captureAndArgumentIncompatibleTypes.kt"); + } + + @TestMetadata("classObject.kt") + public void testClassObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/classObject.kt"); + } + + @TestMetadata("destructuring.kt") + public void testDestructuring() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/destructuring.kt"); + } + + @TestMetadata("destructuringIndexClash.kt") + public void testDestructuringIndexClash() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/destructuringIndexClash.kt"); + } + + @TestMetadata("extension.kt") + public void testExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/extension.kt"); + } + + @TestMetadata("extensionLambda.kt") + public void testExtensionLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/extensionLambda.kt"); + } + + @TestMetadata("funImportedFromObject.kt") + public void testFunImportedFromObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/funImportedFromObject.kt"); + } + + @TestMetadata("inlineCallInInlineLambda.kt") + public void testInlineCallInInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/inlineCallInInlineLambda.kt"); + } + + @TestMetadata("kt17431.kt") + public void testKt17431() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/kt17431.kt"); + } + + @TestMetadata("kt28547.kt") + public void testKt28547() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/kt28547.kt"); + } + + @TestMetadata("kt28547_2.kt") + public void testKt28547_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/kt28547_2.kt"); + } + + @TestMetadata("params.kt") + public void testParams() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/params.kt"); + } + + @TestMetadata("propImportedFromObject.kt") + public void testPropImportedFromObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/propImportedFromObject.kt"); + } + + @TestMetadata("rootConstructor.kt") + public void testRootConstructor() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/rootConstructor.kt"); + } + + @TestMetadata("safeCall.kt") + public void testSafeCall() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/safeCall.kt"); + } + + @TestMetadata("severalClosures.kt") + public void testSeveralClosures() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/severalClosures.kt"); + } + + @TestMetadata("severalUsage.kt") + public void testSeveralUsage() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/severalUsage.kt"); + } + + @TestMetadata("simpleDouble.kt") + public void testSimpleDouble() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/simpleDouble.kt"); + } + + @TestMetadata("simpleEnum.kt") + public void testSimpleEnum() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/simpleEnum.kt"); + } + + @TestMetadata("simpleGenerics.kt") + public void testSimpleGenerics() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/simpleGenerics.kt"); + } + + @TestMetadata("simpleInt.kt") + public void testSimpleInt() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/simpleInt.kt"); + } + + @TestMetadata("simpleLambda.kt") + public void testSimpleLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/simpleLambda.kt"); + } + + @TestMetadata("simpleObject.kt") + public void testSimpleObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/simpleObject.kt"); + } + + @TestMetadata("vararg.kt") + public void testVararg() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/vararg.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/smap") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Smap extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInSmap() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("assertion.kt") + public void testAssertion() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/assertion.kt"); + } + + @TestMetadata("classCycle.kt") + public void testClassCycle() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/classCycle.kt"); + } + + @TestMetadata("classFromDefaultPackage.kt") + public void testClassFromDefaultPackage() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/classFromDefaultPackage.kt"); + } + + @TestMetadata("crossroutines.kt") + public void testCrossroutines() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/crossroutines.kt"); + } + + @TestMetadata("defaultFunction.kt") + public void testDefaultFunction() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultFunction.kt"); + } + + @TestMetadata("defaultFunctionWithInlineCall.kt") + public void testDefaultFunctionWithInlineCall() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultFunctionWithInlineCall.kt"); + } + + @TestMetadata("interleavedFiles.kt") + public void testInterleavedFiles() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/interleavedFiles.kt"); + } + + @TestMetadata("kt23369.kt") + public void testKt23369() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/kt23369.kt"); + } + + @TestMetadata("kt23369_2.kt") + public void testKt23369_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/kt23369_2.kt"); + } + + @TestMetadata("kt23369_3.kt") + public void testKt23369_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/kt23369_3.kt"); + } + + @TestMetadata("kt35006.kt") + public void testKt35006() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/kt35006.kt"); + } + + @TestMetadata("multiFileFacade.kt") + public void testMultiFileFacade() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/multiFileFacade.kt"); + } + + @TestMetadata("oneFile.kt") + public void testOneFile() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/oneFile.kt"); + } + + @TestMetadata("rangeFolding.kt") + public void testRangeFolding() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/rangeFolding.kt"); + } + + @TestMetadata("rangeFoldingInClass.kt") + public void testRangeFoldingInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/rangeFoldingInClass.kt"); + } + + @TestMetadata("smap.kt") + public void testSmap() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/smap.kt"); + } + + @TestMetadata("smapWithNewSyntax.kt") + public void testSmapWithNewSyntax() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/smapWithNewSyntax.kt"); + } + + @TestMetadata("smapWithOldSyntax.kt") + public void testSmapWithOldSyntax() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/smapWithOldSyntax.kt"); + } + + @TestMetadata("compiler/testData/codegen/boxInline/smap/anonymous") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Anonymous extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInAnonymous() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("kt19175.kt") + public void testKt19175() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/kt19175.kt"); + } + + @TestMetadata("lambda.kt") + public void testLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/lambda.kt"); + } + + @TestMetadata("lambdaOnCallSite.kt") + public void testLambdaOnCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/lambdaOnCallSite.kt"); + } + + @TestMetadata("lambdaOnInlineCallSite.kt") + public void testLambdaOnInlineCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/lambdaOnInlineCallSite.kt"); + } + + @TestMetadata("object.kt") + public void testObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/object.kt"); + } + + @TestMetadata("objectOnCallSite.kt") + public void testObjectOnCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/objectOnCallSite.kt"); + } + + @TestMetadata("objectOnInlineCallSite.kt") + public void testObjectOnInlineCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/objectOnInlineCallSite.kt"); + } + + @TestMetadata("objectOnInlineCallSite2.kt") + public void testObjectOnInlineCallSite2() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/objectOnInlineCallSite2.kt"); + } + + @TestMetadata("objectOnInlineCallSiteWithCapture.kt") + public void testObjectOnInlineCallSiteWithCapture() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/objectOnInlineCallSiteWithCapture.kt"); + } + + @TestMetadata("severalMappingsForDefaultFile.kt") + public void testSeveralMappingsForDefaultFile() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/severalMappingsForDefaultFile.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/smap/defaultLambda") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DefaultLambda extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInDefaultLambda() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("defaultLambdaInAnonymous.kt") + public void testDefaultLambdaInAnonymous() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/defaultLambdaInAnonymous.kt"); + } + + @TestMetadata("inlinInDefault.kt") + public void testInlinInDefault() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/inlinInDefault.kt"); + } + + @TestMetadata("inlinInDefault2.kt") + public void testInlinInDefault2() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/inlinInDefault2.kt"); + } + + @TestMetadata("inlineAnonymousInDefault.kt") + public void testInlineAnonymousInDefault() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/inlineAnonymousInDefault.kt"); + } + + @TestMetadata("inlineAnonymousInDefault2.kt") + public void testInlineAnonymousInDefault2() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/inlineAnonymousInDefault2.kt"); + } + + @TestMetadata("kt21827.kt") + public void testKt21827() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/kt21827.kt"); + } + + @TestMetadata("nested.kt") + public void testNested() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/nested.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/simple.kt"); + } + + @TestMetadata("simple2.kt") + public void testSimple2() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/simple2.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/smap/inlineOnly") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineOnly extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInInlineOnly() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/inlineOnly"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("noSmap.kt") + public void testNoSmap() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/inlineOnly/noSmap.kt"); + } + + @TestMetadata("noSmapWithProperty.kt") + public void testNoSmapWithProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/inlineOnly/noSmapWithProperty.kt"); + } + + @TestMetadata("reified.kt") + public void testReified() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/inlineOnly/reified.kt"); + } + + @TestMetadata("reifiedProperty.kt") + public void testReifiedProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/inlineOnly/reifiedProperty.kt"); + } + + @TestMetadata("stdlibInlineOnly.kt") + public void testStdlibInlineOnly() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/inlineOnly/stdlibInlineOnly.kt"); + } + + @TestMetadata("stdlibInlineOnlyOneLine.kt") + public void testStdlibInlineOnlyOneLine() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/inlineOnly/stdlibInlineOnlyOneLine.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/smap/newsmap") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Newsmap extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInNewsmap() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/newsmap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("differentMapping.kt") + public void testDifferentMapping() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/newsmap/differentMapping.kt"); + } + + @TestMetadata("mappingInInlineFunLambda.kt") + public void testMappingInInlineFunLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/newsmap/mappingInInlineFunLambda.kt"); + } + + @TestMetadata("mappingInSubInlineLambda.kt") + public void testMappingInSubInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/newsmap/mappingInSubInlineLambda.kt"); + } + + @TestMetadata("mappingInSubInlineLambdaSameFileInline.kt") + public void testMappingInSubInlineLambdaSameFileInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/newsmap/mappingInSubInlineLambdaSameFileInline.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/smap/resolve") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Resolve extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInResolve() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/resolve"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("inlineComponent.kt") + public void testInlineComponent() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/resolve/inlineComponent.kt"); + } + + @TestMetadata("inlineIterator.kt") + public void testInlineIterator() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/resolve/inlineIterator.kt"); + } + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/special") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Special extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInSpecial() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/special"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("identityCheck.kt") + public void testIdentityCheck() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/identityCheck.kt"); + } + + @TestMetadata("ifBranches.kt") + public void testIfBranches() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/ifBranches.kt"); + } + + @TestMetadata("iinc.kt") + public void testIinc() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/iinc.kt"); + } + + @TestMetadata("inlineChain.kt") + public void testInlineChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/inlineChain.kt"); + } + + @TestMetadata("loopInStoreLoadChains.kt") + public void testLoopInStoreLoadChains() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/loopInStoreLoadChains.kt"); + } + + @TestMetadata("loopInStoreLoadChains2.kt") + public void testLoopInStoreLoadChains2() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/loopInStoreLoadChains2.kt"); + } + + @TestMetadata("plusAssign.kt") + public void testPlusAssign() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/plusAssign.kt"); + } + + @TestMetadata("stackHeightBug.kt") + public void testStackHeightBug() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/stackHeightBug.kt"); + } + + @TestMetadata("unusedInlineLambda.kt") + public void testUnusedInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/unusedInlineLambda.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/stackOnReturn") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class StackOnReturn extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInStackOnReturn() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/stackOnReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("elvis.kt") + public void testElvis() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/elvis.kt"); + } + + @TestMetadata("ifThenElse.kt") + public void testIfThenElse() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/ifThenElse.kt"); + } + + @TestMetadata("kt11499.kt") + public void testKt11499() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/kt11499.kt"); + } + + @TestMetadata("kt17591.kt") + public void testKt17591() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/kt17591.kt"); + } + + @TestMetadata("kt17591a.kt") + public void testKt17591a() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/kt17591a.kt"); + } + + @TestMetadata("kt17591b.kt") + public void testKt17591b() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/kt17591b.kt"); + } + + @TestMetadata("mixedTypesOnStack1.kt") + public void testMixedTypesOnStack1() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/mixedTypesOnStack1.kt"); + } + + @TestMetadata("mixedTypesOnStack2.kt") + public void testMixedTypesOnStack2() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/mixedTypesOnStack2.kt"); + } + + @TestMetadata("mixedTypesOnStack3.kt") + public void testMixedTypesOnStack3() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/mixedTypesOnStack3.kt"); + } + + @TestMetadata("nonLocalReturn1.kt") + public void testNonLocalReturn1() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/nonLocalReturn1.kt"); + } + + @TestMetadata("nonLocalReturn2.kt") + public void testNonLocalReturn2() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/nonLocalReturn2.kt"); + } + + @TestMetadata("nonLocalReturn3.kt") + public void testNonLocalReturn3() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/nonLocalReturn3.kt"); + } + + @TestMetadata("poppedLocalReturn.kt") + public void testPoppedLocalReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/poppedLocalReturn.kt"); + } + + @TestMetadata("poppedLocalReturn2.kt") + public void testPoppedLocalReturn2() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/poppedLocalReturn2.kt"); + } + + @TestMetadata("returnLong.kt") + public void testReturnLong() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/returnLong.kt"); + } + + @TestMetadata("tryFinally.kt") + public void testTryFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/tryFinally.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/suspend") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Suspend extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + private void runTestWithPackageReplacement(String testDataFilePath, String packageName) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(filePath -> doTestWithCoroutinesPackageReplacement(filePath, packageName), TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInSuspend() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("capturedVariables.kt") + public void testCapturedVariables_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/capturedVariables.kt", "kotlin.coroutines"); + } + + @TestMetadata("crossinlineSuspendLambdaInsideCrossinlineSuspendLambda.kt") + public void testCrossinlineSuspendLambdaInsideCrossinlineSuspendLambda_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/crossinlineSuspendLambdaInsideCrossinlineSuspendLambda.kt", "kotlin.coroutines"); + } + + @TestMetadata("delegatedProperties.kt") + public void testDelegatedProperties_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/delegatedProperties.kt", "kotlin.coroutines"); + } + + @TestMetadata("doubleRegenerationWithNonSuspendingLambda.kt") + public void testDoubleRegenerationWithNonSuspendingLambda_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/doubleRegenerationWithNonSuspendingLambda.kt", "kotlin.coroutines"); + } + + @TestMetadata("enclodingMethod.kt") + public void testEnclodingMethod_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/enclodingMethod.kt", "kotlin.coroutines"); + } + + @TestMetadata("fileNameInMetadata.kt") + public void testFileNameInMetadata() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/fileNameInMetadata.kt"); + } + + @TestMetadata("inlineOrdinaryOfCrossinlineSuspend.kt") + public void testInlineOrdinaryOfCrossinlineSuspend_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/inlineOrdinaryOfCrossinlineSuspend.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineOrdinaryOfNoinlineSuspend.kt") + public void testInlineOrdinaryOfNoinlineSuspend_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/inlineOrdinaryOfNoinlineSuspend.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendContinuation.kt") + public void testInlineSuspendContinuation_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/inlineSuspendContinuation.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendInMultifileClass.kt") + public void testInlineSuspendInMultifileClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/inlineSuspendInMultifileClass.kt"); + } + + @TestMetadata("inlineSuspendOfCrossinlineOrdinary.kt") + public void testInlineSuspendOfCrossinlineOrdinary_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/inlineSuspendOfCrossinlineOrdinary.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendOfCrossinlineSuspend.kt") + public void testInlineSuspendOfCrossinlineSuspend_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/inlineSuspendOfCrossinlineSuspend.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendOfNoinlineOrdinary.kt") + public void testInlineSuspendOfNoinlineOrdinary_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/inlineSuspendOfNoinlineOrdinary.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendOfNoinlineSuspend.kt") + public void testInlineSuspendOfNoinlineSuspend_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/inlineSuspendOfNoinlineSuspend.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendOfOrdinary.kt") + public void testInlineSuspendOfOrdinary_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/inlineSuspendOfOrdinary.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendOfSuspend.kt") + public void testInlineSuspendOfSuspend_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/inlineSuspendOfSuspend.kt", "kotlin.coroutines"); + } + + @TestMetadata("jvmName.kt") + public void testJvmName_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/jvmName.kt", "kotlin.coroutines"); + } + + @TestMetadata("kt26658.kt") + public void testKt26658() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/kt26658.kt"); + } + + @TestMetadata("maxStackWithCrossinline.kt") + public void testMaxStackWithCrossinline_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/maxStackWithCrossinline.kt", "kotlin.coroutines"); + } + + @TestMetadata("multipleLocals.kt") + public void testMultipleLocals_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/multipleLocals.kt", "kotlin.coroutines"); + } + + @TestMetadata("multipleSuspensionPoints.kt") + public void testMultipleSuspensionPoints_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/multipleSuspensionPoints.kt", "kotlin.coroutines"); + } + + @TestMetadata("nestedMethodWith2XParameter.kt") + public void testNestedMethodWith2XParameter() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/nestedMethodWith2XParameter.kt"); + } + + @TestMetadata("nonLocalReturn.kt") + public void testNonLocalReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/nonLocalReturn.kt"); + } + + @TestMetadata("nonSuspendCrossinline.kt") + public void testNonSuspendCrossinline_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/nonSuspendCrossinline.kt", "kotlin.coroutines"); + } + + @TestMetadata("returnValue.kt") + public void testReturnValue_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/returnValue.kt", "kotlin.coroutines"); + } + + @TestMetadata("tryCatchReceiver.kt") + public void testTryCatchReceiver_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/tryCatchReceiver.kt", "kotlin.coroutines"); + } + + @TestMetadata("tryCatchStackTransform.kt") + public void testTryCatchStackTransform_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/tryCatchStackTransform.kt", "kotlin.coroutines"); + } + + @TestMetadata("twiceRegeneratedAnonymousObject.kt") + public void testTwiceRegeneratedAnonymousObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/twiceRegeneratedAnonymousObject.kt"); + } + + @TestMetadata("twiceRegeneratedSuspendLambda.kt") + public void testTwiceRegeneratedSuspendLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/twiceRegeneratedSuspendLambda.kt"); + } + + @TestMetadata("compiler/testData/codegen/boxInline/suspend/callableReference") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CallableReference extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInCallableReference() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("nonTailCall.kt") + public void testNonTailCall() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/callableReference/nonTailCall.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/callableReference/simple.kt"); + } + + @TestMetadata("unitReturn.kt") + public void testUnitReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/callableReference/unitReturn.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/suspend/defaultParameter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DefaultParameter extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + private void runTestWithPackageReplacement(String testDataFilePath, String packageName) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(filePath -> doTestWithCoroutinesPackageReplacement(filePath, packageName), TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInDefaultParameter() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/defaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("defaultValueCrossinline.kt") + public void testDefaultValueCrossinline_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/defaultParameter/defaultValueCrossinline.kt", "kotlin.coroutines"); + } + + @TestMetadata("defaultValueInClass.kt") + public void testDefaultValueInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/defaultParameter/defaultValueInClass.kt"); + } + + @TestMetadata("defaultValueInlineFromMultiFileFacade.kt") + public void testDefaultValueInlineFromMultiFileFacade_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/defaultParameter/defaultValueInlineFromMultiFileFacade.kt", "kotlin.coroutines"); + } + + @TestMetadata("defaultValueInline.kt") + public void testDefaultValueInline_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/defaultParameter/defaultValueInline.kt", "kotlin.coroutines"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineUsedAsNoinline extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInInlineUsedAsNoinline() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("inlineOnly.kt") + public void testInlineOnly() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline/inlineOnly.kt"); + } + + @TestMetadata("simpleNamed.kt") + public void testSimpleNamed() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline/simpleNamed.kt"); + } + + @TestMetadata("withCapturedInlineLambda.kt") + public void testWithCapturedInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline/withCapturedInlineLambda.kt"); + } + + @TestMetadata("withCapturedInlineLambda2.kt") + public void testWithCapturedInlineLambda2() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline/withCapturedInlineLambda2.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/suspend/receiver") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Receiver extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + private void runTestWithPackageReplacement(String testDataFilePath, String packageName) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(filePath -> doTestWithCoroutinesPackageReplacement(filePath, packageName), TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInReceiver() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/receiver"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("inlineOrdinaryOfCrossinlineSuspend.kt") + public void testInlineOrdinaryOfCrossinlineSuspend_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/receiver/inlineOrdinaryOfCrossinlineSuspend.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineOrdinaryOfNoinlineSuspend.kt") + public void testInlineOrdinaryOfNoinlineSuspend_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/receiver/inlineOrdinaryOfNoinlineSuspend.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendOfCrossinlineOrdinary.kt") + public void testInlineSuspendOfCrossinlineOrdinary_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfCrossinlineOrdinary.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendOfCrossinlineSuspend.kt") + public void testInlineSuspendOfCrossinlineSuspend_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfCrossinlineSuspend.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendOfNoinlineOrdinary.kt") + public void testInlineSuspendOfNoinlineOrdinary_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfNoinlineOrdinary.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendOfNoinlineSuspend.kt") + public void testInlineSuspendOfNoinlineSuspend_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfNoinlineSuspend.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendOfOrdinary.kt") + public void testInlineSuspendOfOrdinary_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfOrdinary.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendOfSuspend.kt") + public void testInlineSuspendOfSuspend_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfSuspend.kt", "kotlin.coroutines"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/suspend/stateMachine") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class StateMachine extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + private void runTestWithPackageReplacement(String testDataFilePath, String packageName) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(filePath -> doTestWithCoroutinesPackageReplacement(filePath, packageName), TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInStateMachine() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("crossingCoroutineBoundaries.kt") + public void testCrossingCoroutineBoundaries_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/crossingCoroutineBoundaries.kt", "kotlin.coroutines"); + } + + @TestMetadata("independentInline.kt") + public void testIndependentInline_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/independentInline.kt", "kotlin.coroutines"); + } + + @TestMetadata("innerLambdaInsideLambda.kt") + public void testInnerLambdaInsideLambda_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/innerLambdaInsideLambda.kt", "kotlin.coroutines"); + } + + @TestMetadata("innerLambdaWithoutCrossinline.kt") + public void testInnerLambdaWithoutCrossinline_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/innerLambdaWithoutCrossinline.kt", "kotlin.coroutines"); + } + + @TestMetadata("innerLambda.kt") + public void testInnerLambda_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/innerLambda.kt", "kotlin.coroutines"); + } + + @TestMetadata("innerMadnessCallSite.kt") + public void testInnerMadnessCallSite_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/innerMadnessCallSite.kt", "kotlin.coroutines"); + } + + @TestMetadata("innerMadness.kt") + public void testInnerMadness_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/innerMadness.kt", "kotlin.coroutines"); + } + + @TestMetadata("innerObjectInsideInnerObject.kt") + public void testInnerObjectInsideInnerObject_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/innerObjectInsideInnerObject.kt", "kotlin.coroutines"); + } + + @TestMetadata("innerObjectRetransformation.kt") + public void testInnerObjectRetransformation_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/innerObjectRetransformation.kt", "kotlin.coroutines"); + } + + @TestMetadata("innerObjectSeveralFunctions.kt") + public void testInnerObjectSeveralFunctions_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/innerObjectSeveralFunctions.kt", "kotlin.coroutines"); + } + + @TestMetadata("innerObjectWithoutCapturingCrossinline.kt") + public void testInnerObjectWithoutCapturingCrossinline_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/innerObjectWithoutCapturingCrossinline.kt", "kotlin.coroutines"); + } + + @TestMetadata("innerObject.kt") + public void testInnerObject_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/innerObject.kt", "kotlin.coroutines"); + } + + @TestMetadata("insideObject.kt") + public void testInsideObject_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/insideObject.kt", "kotlin.coroutines"); + } + + @TestMetadata("lambdaTransformation.kt") + public void testLambdaTransformation() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/lambdaTransformation.kt"); + } + + @TestMetadata("normalInline.kt") + public void testNormalInline_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/normalInline.kt", "kotlin.coroutines"); + } + + @TestMetadata("numberOfSuspentions.kt") + public void testNumberOfSuspentions_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/numberOfSuspentions.kt", "kotlin.coroutines"); + } + + @TestMetadata("objectInsideLambdas.kt") + public void testObjectInsideLambdas_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/objectInsideLambdas.kt", "kotlin.coroutines"); + } + + @TestMetadata("oneInlineTwoCaptures.kt") + public void testOneInlineTwoCaptures_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/oneInlineTwoCaptures.kt", "kotlin.coroutines"); + } + + @TestMetadata("passLambda.kt") + public void testPassLambda_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/passLambda.kt", "kotlin.coroutines"); + } + + @TestMetadata("passParameterLambda.kt") + public void testPassParameterLambda_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/passParameterLambda.kt", "kotlin.coroutines"); + } + + @TestMetadata("passParameter.kt") + public void testPassParameter_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/passParameter.kt", "kotlin.coroutines"); + } + + @TestMetadata("unreachableSuspendMarker.kt") + public void testUnreachableSuspendMarker_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/unreachableSuspendMarker.kt", "kotlin.coroutines"); + } + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/syntheticAccessors") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SyntheticAccessors extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInSyntheticAccessors() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("constField.kt") + public void testConstField() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/constField.kt"); + } + + @TestMetadata("packagePrivateMembers.kt") + public void testPackagePrivateMembers() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/packagePrivateMembers.kt"); + } + + @TestMetadata("propertyModifiers.kt") + public void testPropertyModifiers() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/propertyModifiers.kt"); + } + + @TestMetadata("protectedMembers.kt") + public void testProtectedMembers() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/protectedMembers.kt"); + } + + @TestMetadata("protectedMembersFromSuper.kt") + public void testProtectedMembersFromSuper() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/protectedMembersFromSuper.kt"); + } + + @TestMetadata("superCall.kt") + public void testSuperCall() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/superCall.kt"); + } + + @TestMetadata("superCallFromMultipleSubclasses.kt") + public void testSuperCallFromMultipleSubclasses() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/superCallFromMultipleSubclasses.kt"); + } + + @TestMetadata("superProperty.kt") + public void testSuperProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/superProperty.kt"); + } + + @TestMetadata("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class WithinInlineLambda extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInWithinInlineLambda() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("directFieldAccess.kt") + public void testDirectFieldAccess() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/directFieldAccess.kt"); + } + + @TestMetadata("directFieldAccessInCrossInline.kt") + public void testDirectFieldAccessInCrossInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/directFieldAccessInCrossInline.kt"); + } + + @TestMetadata("privateCall.kt") + public void testPrivateCall() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/privateCall.kt"); + } + + @TestMetadata("privateInCrossInline.kt") + public void testPrivateInCrossInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/privateInCrossInline.kt"); + } + + @TestMetadata("privateInDefaultStubArgument.kt") + public void testPrivateInDefaultStubArgument() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/privateInDefaultStubArgument.kt"); + } + + @TestMetadata("protectedInCrossinline.kt") + public void testProtectedInCrossinline() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/protectedInCrossinline.kt"); + } + + @TestMetadata("protectedMembersFromSuper.kt") + public void testProtectedMembersFromSuper() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/protectedMembersFromSuper.kt"); + } + + @TestMetadata("superCall.kt") + public void testSuperCall() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/superCall.kt"); + } + + @TestMetadata("superInCrossInline.kt") + public void testSuperInCrossInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/superInCrossInline.kt"); + } + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/trait") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Trait extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInTrait() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("trait.kt") + public void testTrait() throws Exception { + runTest("compiler/testData/codegen/boxInline/trait/trait.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/tryCatchFinally") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TryCatchFinally extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInTryCatchFinally() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("kt5863.kt") + public void testKt5863() throws Exception { + runTest("compiler/testData/codegen/boxInline/tryCatchFinally/kt5863.kt"); + } + + @TestMetadata("tryCatch.kt") + public void testTryCatch() throws Exception { + runTest("compiler/testData/codegen/boxInline/tryCatchFinally/tryCatch.kt"); + } + + @TestMetadata("tryCatch2.kt") + public void testTryCatch2() throws Exception { + runTest("compiler/testData/codegen/boxInline/tryCatchFinally/tryCatch2.kt"); + } + + @TestMetadata("tryCatchFinally.kt") + public void testTryCatchFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/tryCatchFinally/tryCatchFinally.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/varargs") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Varargs extends AbstractJvmIrAgainstOldBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInVarargs() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("kt17653.kt") + public void testKt17653() throws Exception { + runTest("compiler/testData/codegen/boxInline/varargs/kt17653.kt"); + } + + @TestMetadata("varargAndDefaultParameters.kt") + public void testVarargAndDefaultParameters() throws Exception { + runTest("compiler/testData/codegen/boxInline/varargs/varargAndDefaultParameters.kt"); + } + + @TestMetadata("varargAndDefaultParameters2.kt") + public void testVarargAndDefaultParameters2() throws Exception { + runTest("compiler/testData/codegen/boxInline/varargs/varargAndDefaultParameters2.kt"); + } + } +} diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/ir/JvmIrAgainstOldBoxTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/ir/JvmIrAgainstOldBoxTestGenerated.java new file mode 100644 index 00000000000..796c9aff032 --- /dev/null +++ b/compiler/tests/org/jetbrains/kotlin/codegen/ir/JvmIrAgainstOldBoxTestGenerated.java @@ -0,0 +1,639 @@ +/* + * Copyright 2010-2020 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.codegen.ir; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; +import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.TargetBackend; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.runner.RunWith; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("compiler/testData/compileKotlinAgainstKotlin") +@TestDataPath("$PROJECT_ROOT") +@RunWith(JUnit3RunnerWithInners.class) +public class JvmIrAgainstOldBoxTestGenerated extends AbstractJvmIrAgainstOldBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath); + } + + private void runTestWithPackageReplacement(String testDataFilePath, String packageName) throws Exception { + KotlinTestUtils.runTest(filePath -> doTestWithCoroutinesPackageReplacement(filePath, packageName), TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath); + } + + public void testAllFilesPresentInCompileKotlinAgainstKotlin() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("annotationInInterface.kt") + public void testAnnotationInInterface() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/annotationInInterface.kt"); + } + + @TestMetadata("annotationOnTypeUseInTypeAlias.kt") + public void testAnnotationOnTypeUseInTypeAlias() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/annotationOnTypeUseInTypeAlias.kt"); + } + + @TestMetadata("annotationsOnTypeAliases.kt") + public void testAnnotationsOnTypeAliases() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/annotationsOnTypeAliases.kt"); + } + + @TestMetadata("callDeserializedPropertyOnInlineClassType.kt") + public void testCallDeserializedPropertyOnInlineClassType() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/callDeserializedPropertyOnInlineClassType.kt"); + } + + @TestMetadata("callsToMultifileClassFromOtherPackage.kt") + public void testCallsToMultifileClassFromOtherPackage() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/callsToMultifileClassFromOtherPackage.kt"); + } + + @TestMetadata("classInObject.kt") + public void testClassInObject() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/classInObject.kt"); + } + + @TestMetadata("companionObjectInEnum.kt") + public void testCompanionObjectInEnum() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/companionObjectInEnum.kt"); + } + + @TestMetadata("companionObjectMember.kt") + public void testCompanionObjectMember() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/companionObjectMember.kt"); + } + + @TestMetadata("constPropertyReferenceFromMultifileClass.kt") + public void testConstPropertyReferenceFromMultifileClass() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/constPropertyReferenceFromMultifileClass.kt"); + } + + @TestMetadata("constructorVararg.kt") + public void testConstructorVararg() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/constructorVararg.kt"); + } + + @TestMetadata("constructorWithInlineClassParametersInBinaryDependencies.kt") + public void testConstructorWithInlineClassParametersInBinaryDependencies() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/constructorWithInlineClassParametersInBinaryDependencies.kt"); + } + + @TestMetadata("copySamOnInline.kt") + public void testCopySamOnInline() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/copySamOnInline.kt"); + } + + @TestMetadata("copySamOnInline2.kt") + public void testCopySamOnInline2() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/copySamOnInline2.kt"); + } + + @TestMetadata("coroutinesBinary.kt") + public void testCoroutinesBinary_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/compileKotlinAgainstKotlin/coroutinesBinary.kt", "kotlin.coroutines"); + } + + @TestMetadata("defaultConstructor.kt") + public void testDefaultConstructor() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/defaultConstructor.kt"); + } + + @TestMetadata("defaultLambdaRegeneration.kt") + public void testDefaultLambdaRegeneration() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/defaultLambdaRegeneration.kt"); + } + + @TestMetadata("defaultLambdaRegeneration2.kt") + public void testDefaultLambdaRegeneration2() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/defaultLambdaRegeneration2.kt"); + } + + @TestMetadata("delegatedDefault.kt") + public void testDelegatedDefault() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/delegatedDefault.kt"); + } + + @TestMetadata("delegationAndAnnotations.kt") + public void testDelegationAndAnnotations() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/delegationAndAnnotations.kt"); + } + + @TestMetadata("doublyNestedClass.kt") + public void testDoublyNestedClass() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/doublyNestedClass.kt"); + } + + @TestMetadata("enum.kt") + public void testEnum() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/enum.kt"); + } + + @TestMetadata("expectClassActualTypeAlias.kt") + public void testExpectClassActualTypeAlias() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/expectClassActualTypeAlias.kt"); + } + + @TestMetadata("inlineClassFromBinaryDependencies.kt") + public void testInlineClassFromBinaryDependencies() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/inlineClassFromBinaryDependencies.kt"); + } + + @TestMetadata("inlineClassInlineProperty.kt") + public void testInlineClassInlineProperty() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/inlineClassInlineProperty.kt"); + } + + @TestMetadata("inlinedConstants.kt") + public void testInlinedConstants() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/inlinedConstants.kt"); + } + + @TestMetadata("innerClassConstructor.kt") + public void testInnerClassConstructor() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/innerClassConstructor.kt"); + } + + @TestMetadata("interfaceDelegationAndBridgesProcessing.kt") + public void testInterfaceDelegationAndBridgesProcessing() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/interfaceDelegationAndBridgesProcessing.kt"); + } + + @TestMetadata("internalSetterOverridden.kt") + public void testInternalSetterOverridden() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/internalSetterOverridden.kt"); + } + + @TestMetadata("internalWithOtherModuleName.kt") + public void testInternalWithOtherModuleName() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/internalWithOtherModuleName.kt"); + } + + @TestMetadata("jvmField.kt") + public void testJvmField() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvmField.kt"); + } + + @TestMetadata("jvmFieldInAnnotationCompanion.kt") + public void testJvmFieldInAnnotationCompanion() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvmFieldInAnnotationCompanion.kt"); + } + + @TestMetadata("jvmFieldInConstructor.kt") + public void testJvmFieldInConstructor() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvmFieldInConstructor.kt"); + } + + @TestMetadata("jvmFieldInInterfaceCompanion.kt") + public void testJvmFieldInInterfaceCompanion() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvmFieldInInterfaceCompanion.kt"); + } + + @TestMetadata("jvmNames.kt") + public void testJvmNames() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvmNames.kt"); + } + + @TestMetadata("jvmPackageName.kt") + public void testJvmPackageName() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvmPackageName.kt"); + } + + @TestMetadata("jvmPackageNameInRootPackage.kt") + public void testJvmPackageNameInRootPackage() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvmPackageNameInRootPackage.kt"); + } + + @TestMetadata("jvmPackageNameMultifileClass.kt") + public void testJvmPackageNameMultifileClass() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvmPackageNameMultifileClass.kt"); + } + + @TestMetadata("jvmPackageNameWithJvmName.kt") + public void testJvmPackageNameWithJvmName() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvmPackageNameWithJvmName.kt"); + } + + @TestMetadata("jvmStaticInObject.kt") + public void testJvmStaticInObject() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvmStaticInObject.kt"); + } + + @TestMetadata("kotlinPropertyAsAnnotationParameter.kt") + public void testKotlinPropertyAsAnnotationParameter() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/kotlinPropertyAsAnnotationParameter.kt"); + } + + @TestMetadata("kt14012.kt") + public void testKt14012() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/kt14012.kt"); + } + + @TestMetadata("kt14012_multi.kt") + public void testKt14012_multi() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/kt14012_multi.kt"); + } + + @TestMetadata("kt21775.kt") + public void testKt21775() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/kt21775.kt"); + } + + @TestMetadata("metadataForMembersInLocalClassInInitializer.kt") + public void testMetadataForMembersInLocalClassInInitializer() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/metadataForMembersInLocalClassInInitializer.kt"); + } + + @TestMetadata("multifileClassInlineFunctionAccessingProperty.kt") + public void testMultifileClassInlineFunctionAccessingProperty() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/multifileClassInlineFunctionAccessingProperty.kt"); + } + + @TestMetadata("multifileClassWithTypealias.kt") + public void testMultifileClassWithTypealias() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/multifileClassWithTypealias.kt"); + } + + @TestMetadata("nestedClass.kt") + public void testNestedClass() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/nestedClass.kt"); + } + + @TestMetadata("nestedClassInAnnotationArgument.kt") + public void testNestedClassInAnnotationArgument() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/nestedClassInAnnotationArgument.kt"); + } + + @TestMetadata("nestedEnum.kt") + public void testNestedEnum() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/nestedEnum.kt"); + } + + @TestMetadata("nestedFunctionTypeAliasExpansion.kt") + public void testNestedFunctionTypeAliasExpansion() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/nestedFunctionTypeAliasExpansion.kt"); + } + + @TestMetadata("nestedObject.kt") + public void testNestedObject() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/nestedObject.kt"); + } + + @TestMetadata("nestedTypeAliasExpansion.kt") + public void testNestedTypeAliasExpansion() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/nestedTypeAliasExpansion.kt"); + } + + @TestMetadata("optionalAnnotation.kt") + public void testOptionalAnnotation() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/optionalAnnotation.kt"); + } + + @TestMetadata("platformTypes.kt") + public void testPlatformTypes() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/platformTypes.kt"); + } + + @TestMetadata("privateCompanionObjectValInDifferentModule.kt") + public void testPrivateCompanionObjectValInDifferentModule() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/privateCompanionObjectValInDifferentModule.kt"); + } + + @TestMetadata("privateTopLevelValInDifferentModule.kt") + public void testPrivateTopLevelValInDifferentModule() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/privateTopLevelValInDifferentModule.kt"); + } + + @TestMetadata("propertyReference.kt") + public void testPropertyReference() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/propertyReference.kt"); + } + + @TestMetadata("recursiveGeneric.kt") + public void testRecursiveGeneric() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/recursiveGeneric.kt"); + } + + @TestMetadata("reflectTopLevelFunctionOtherFile.kt") + public void testReflectTopLevelFunctionOtherFile() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/reflectTopLevelFunctionOtherFile.kt"); + } + + @TestMetadata("sealedClass.kt") + public void testSealedClass() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/sealedClass.kt"); + } + + @TestMetadata("secondaryConstructors.kt") + public void testSecondaryConstructors() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/secondaryConstructors.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/simple.kt"); + } + + @TestMetadata("simpleValAnonymousObject.kt") + public void testSimpleValAnonymousObject() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/simpleValAnonymousObject.kt"); + } + + @TestMetadata("specialBridgesInDependencies.kt") + public void testSpecialBridgesInDependencies() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/specialBridgesInDependencies.kt"); + } + + @TestMetadata("starImportEnum.kt") + public void testStarImportEnum() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/starImportEnum.kt"); + } + + @TestMetadata("targetedJvmName.kt") + public void testTargetedJvmName() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/targetedJvmName.kt"); + } + + @TestMetadata("typeAliasesKt13181.kt") + public void testTypeAliasesKt13181() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/typeAliasesKt13181.kt"); + } + + @TestMetadata("unsignedTypesInAnnotations.kt") + public void testUnsignedTypesInAnnotations() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/unsignedTypesInAnnotations.kt"); + } + + @TestMetadata("useDeserializedFunInterface.kt") + public void testUseDeserializedFunInterface() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/useDeserializedFunInterface.kt"); + } + + @TestMetadata("compiler/testData/compileKotlinAgainstKotlin/jvm8") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Jvm8 extends AbstractJvmIrAgainstOldBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath); + } + + public void testAllFilesPresentInJvm8() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Defaults extends AbstractJvmIrAgainstOldBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath); + } + + public void testAllFilesPresentInDefaults() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("superCall.kt") + public void testSuperCall() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/superCall.kt"); + } + + @TestMetadata("superCallFromInterface.kt") + public void testSuperCallFromInterface() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/superCallFromInterface.kt"); + } + + @TestMetadata("superCallFromInterface2.kt") + public void testSuperCallFromInterface2() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/superCallFromInterface2.kt"); + } + + @TestMetadata("superPropAccess.kt") + public void testSuperPropAccess() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/superPropAccess.kt"); + } + + @TestMetadata("superPropAccessFromInterface.kt") + public void testSuperPropAccessFromInterface() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/superPropAccessFromInterface.kt"); + } + + @TestMetadata("superPropAccessFromInterface2.kt") + public void testSuperPropAccessFromInterface2() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/superPropAccessFromInterface2.kt"); + } + + @TestMetadata("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AllCompatibility extends AbstractJvmIrAgainstOldBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath); + } + + public void testAllFilesPresentInAllCompatibility() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("callStackTrace.kt") + public void testCallStackTrace() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/callStackTrace.kt"); + } + + @TestMetadata("superCall.kt") + public void testSuperCall() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superCall.kt"); + } + + @TestMetadata("superCallFromInterface.kt") + public void testSuperCallFromInterface() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superCallFromInterface.kt"); + } + + @TestMetadata("superCallFromInterface2.kt") + public void testSuperCallFromInterface2() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superCallFromInterface2.kt"); + } + + @TestMetadata("superPropAccess.kt") + public void testSuperPropAccess() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superPropAccess.kt"); + } + + @TestMetadata("superPropAccessFromInterface.kt") + public void testSuperPropAccessFromInterface() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superPropAccessFromInterface.kt"); + } + + @TestMetadata("superPropAccessFromInterface2.kt") + public void testSuperPropAccessFromInterface2() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superPropAccessFromInterface2.kt"); + } + + @TestMetadata("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/delegationBy") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DelegationBy extends AbstractJvmIrAgainstOldBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath); + } + + public void testAllFilesPresentInDelegationBy() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/delegationBy/simple.kt"); + } + + @TestMetadata("simpleProperty.kt") + public void testSimpleProperty() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/delegationBy/simpleProperty.kt"); + } + } + } + + @TestMetadata("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Interop extends AbstractJvmIrAgainstOldBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath); + } + + public void testAllFilesPresentInInterop() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("likeMemberClash.kt") + public void testLikeMemberClash() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop/likeMemberClash.kt"); + } + + @TestMetadata("likeSpecialization.kt") + public void testLikeSpecialization() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop/likeSpecialization.kt"); + } + + @TestMetadata("newAndOldSchemes.kt") + public void testNewAndOldSchemes() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop/newAndOldSchemes.kt"); + } + + @TestMetadata("newAndOldSchemes2.kt") + public void testNewAndOldSchemes2() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop/newAndOldSchemes2.kt"); + } + + @TestMetadata("newAndOldSchemes2Compatibility.kt") + public void testNewAndOldSchemes2Compatibility() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop/newAndOldSchemes2Compatibility.kt"); + } + + @TestMetadata("newSchemeWithJvmDefault.kt") + public void testNewSchemeWithJvmDefault() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop/newSchemeWithJvmDefault.kt"); + } + } + } + + @TestMetadata("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Jvm8against6 extends AbstractJvmIrAgainstOldBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath); + } + + public void testAllFilesPresentInJvm8against6() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("jdk8Against6.kt") + public void testJdk8Against6() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/jdk8Against6.kt"); + } + + @TestMetadata("simpleCall.kt") + public void testSimpleCall() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/simpleCall.kt"); + } + + @TestMetadata("simpleCallWithBigHierarchy.kt") + public void testSimpleCallWithBigHierarchy() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/simpleCallWithBigHierarchy.kt"); + } + + @TestMetadata("simpleCallWithHierarchy.kt") + public void testSimpleCallWithHierarchy() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/simpleCallWithHierarchy.kt"); + } + + @TestMetadata("simpleProp.kt") + public void testSimpleProp() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/simpleProp.kt"); + } + + @TestMetadata("simplePropWithHierarchy.kt") + public void testSimplePropWithHierarchy() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/simplePropWithHierarchy.kt"); + } + + @TestMetadata("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/delegation") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Delegation extends AbstractJvmIrAgainstOldBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath); + } + + public void testAllFilesPresentInDelegation() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("diamond.kt") + public void testDiamond() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/delegation/diamond.kt"); + } + + @TestMetadata("diamond2.kt") + public void testDiamond2() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/delegation/diamond2.kt"); + } + + @TestMetadata("diamond3.kt") + public void testDiamond3() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/delegation/diamond3.kt"); + } + } + } + } + + @TestMetadata("compiler/testData/compileKotlinAgainstKotlin/typeAnnotations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeAnnotations extends AbstractJvmIrAgainstOldBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, testDataFilePath); + } + + public void testAllFilesPresentInTypeAnnotations() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD, true); + } + + @TestMetadata("implicitReturn.kt") + public void testImplicitReturn() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/typeAnnotations/implicitReturn.kt"); + } + } +} diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/ir/JvmOldAgainstIrBoxInlineTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/ir/JvmOldAgainstIrBoxInlineTestGenerated.java new file mode 100644 index 00000000000..7564f894aaf --- /dev/null +++ b/compiler/tests/org/jetbrains/kotlin/codegen/ir/JvmOldAgainstIrBoxInlineTestGenerated.java @@ -0,0 +1,4418 @@ +/* + * Copyright 2010-2020 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.codegen.ir; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; +import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.TargetBackend; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.runner.RunWith; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("compiler/testData/codegen/boxInline") +@TestDataPath("$PROJECT_ROOT") +@RunWith(JUnit3RunnerWithInners.class) +public class JvmOldAgainstIrBoxInlineTestGenerated extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInBoxInline() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AnonymousObject extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInAnonymousObject() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("anonymousObjectInDefault.kt") + public void testAnonymousObjectInDefault() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectInDefault.kt"); + } + + @TestMetadata("anonymousObjectOnCallSite.kt") + public void testAnonymousObjectOnCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectOnCallSite.kt"); + } + + @TestMetadata("anonymousObjectOnCallSiteSuperParams.kt") + public void testAnonymousObjectOnCallSiteSuperParams() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectOnCallSiteSuperParams.kt"); + } + + @TestMetadata("anonymousObjectOnDeclarationSite.kt") + public void testAnonymousObjectOnDeclarationSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectOnDeclarationSite.kt"); + } + + @TestMetadata("anonymousObjectOnDeclarationSiteSuperParams.kt") + public void testAnonymousObjectOnDeclarationSiteSuperParams() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectOnDeclarationSiteSuperParams.kt"); + } + + @TestMetadata("capturedLambdaInInline.kt") + public void testCapturedLambdaInInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/capturedLambdaInInline.kt"); + } + + @TestMetadata("capturedLambdaInInline2.kt") + public void testCapturedLambdaInInline2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/capturedLambdaInInline2.kt"); + } + + @TestMetadata("capturedLambdaInInline3.kt") + public void testCapturedLambdaInInline3() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/capturedLambdaInInline3.kt"); + } + + @TestMetadata("capturedLambdaInInlineObject.kt") + public void testCapturedLambdaInInlineObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/capturedLambdaInInlineObject.kt"); + } + + @TestMetadata("capturedLocalFun.kt") + public void testCapturedLocalFun() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/capturedLocalFun.kt"); + } + + @TestMetadata("capturedLocalFunRef.kt") + public void testCapturedLocalFunRef() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/capturedLocalFunRef.kt"); + } + + @TestMetadata("changingReturnType.kt") + public void testChangingReturnType() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/changingReturnType.kt"); + } + + @TestMetadata("constructorVisibility.kt") + public void testConstructorVisibility() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/constructorVisibility.kt"); + } + + @TestMetadata("constructorVisibilityInConstLambda.kt") + public void testConstructorVisibilityInConstLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/constructorVisibilityInConstLambda.kt"); + } + + @TestMetadata("constructorVisibilityInLambda.kt") + public void testConstructorVisibilityInLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/constructorVisibilityInLambda.kt"); + } + + @TestMetadata("defineClass.kt") + public void testDefineClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/defineClass.kt"); + } + + @TestMetadata("functionExpression.kt") + public void testFunctionExpression() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/functionExpression.kt"); + } + + @TestMetadata("inlineCallInsideInlineLambda.kt") + public void testInlineCallInsideInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/inlineCallInsideInlineLambda.kt"); + } + + @TestMetadata("kt13133.kt") + public void testKt13133() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt13133.kt"); + } + + @TestMetadata("kt13182.kt") + public void testKt13182() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt13182.kt"); + } + + @TestMetadata("kt13374.kt") + public void testKt13374() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt13374.kt"); + } + + @TestMetadata("kt14011.kt") + public void testKt14011() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt14011.kt"); + } + + @TestMetadata("kt14011_2.kt") + public void testKt14011_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt14011_2.kt"); + } + + @TestMetadata("kt14011_3.kt") + public void testKt14011_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt14011_3.kt"); + } + + @TestMetadata("kt15751.kt") + public void testKt15751() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt15751.kt"); + } + + @TestMetadata("kt16193.kt") + public void testKt16193() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt16193.kt"); + } + + @TestMetadata("kt17972.kt") + public void testKt17972() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972.kt"); + } + + @TestMetadata("kt17972_2.kt") + public void testKt17972_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_2.kt"); + } + + @TestMetadata("kt17972_3.kt") + public void testKt17972_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_3.kt"); + } + + @TestMetadata("kt17972_4.kt") + public void testKt17972_4() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_4.kt"); + } + + @TestMetadata("kt17972_5.kt") + public void testKt17972_5() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_5.kt"); + } + + @TestMetadata("kt17972_super.kt") + public void testKt17972_super() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_super.kt"); + } + + @TestMetadata("kt17972_super2.kt") + public void testKt17972_super2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_super2.kt"); + } + + @TestMetadata("kt17972_super3.kt") + public void testKt17972_super3() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_super3.kt"); + } + + @TestMetadata("kt19389.kt") + public void testKt19389() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt19389.kt"); + } + + @TestMetadata("kt19399.kt") + public void testKt19399() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt19399.kt"); + } + + @TestMetadata("kt19434.kt") + public void testKt19434() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt19434.kt"); + } + + @TestMetadata("kt19434_2.kt") + public void testKt19434_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt19434_2.kt"); + } + + @TestMetadata("kt19723.kt") + public void testKt19723() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt19723.kt"); + } + + @TestMetadata("kt34656.kt") + public void testKt34656() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt34656.kt"); + } + + @TestMetadata("kt38197.kt") + public void testKt38197() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt38197.kt"); + } + + @TestMetadata("kt6552.kt") + public void testKt6552() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt6552.kt"); + } + + @TestMetadata("kt8133.kt") + public void testKt8133() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt8133.kt"); + } + + @TestMetadata("kt9064.kt") + public void testKt9064() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt9064.kt"); + } + + @TestMetadata("kt9064v2.kt") + public void testKt9064v2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt9064v2.kt"); + } + + @TestMetadata("kt9591.kt") + public void testKt9591() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt9591.kt"); + } + + @TestMetadata("kt9877.kt") + public void testKt9877() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt9877.kt"); + } + + @TestMetadata("kt9877_2.kt") + public void testKt9877_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt9877_2.kt"); + } + + @TestMetadata("objectInLambdaCapturesAnotherObject.kt") + public void testObjectInLambdaCapturesAnotherObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/objectInLambdaCapturesAnotherObject.kt"); + } + + @TestMetadata("safeCall.kt") + public void testSafeCall() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/safeCall.kt"); + } + + @TestMetadata("safeCall_2.kt") + public void testSafeCall_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/safeCall_2.kt"); + } + + @TestMetadata("sam.kt") + public void testSam() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/sam.kt"); + } + + @TestMetadata("sharedFromCrossinline.kt") + public void testSharedFromCrossinline() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/sharedFromCrossinline.kt"); + } + + @TestMetadata("superConstructorWithObjectParameter.kt") + public void testSuperConstructorWithObjectParameter() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/superConstructorWithObjectParameter.kt"); + } + + @TestMetadata("typeInfo.kt") + public void testTypeInfo() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/typeInfo.kt"); + } + + @TestMetadata("withInlineMethod.kt") + public void testWithInlineMethod() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/withInlineMethod.kt"); + } + + @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject/enumWhen") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class EnumWhen extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInEnumWhen() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumWhen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("callSite.kt") + public void testCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/enumWhen/callSite.kt"); + } + + @TestMetadata("declSite.kt") + public void testDeclSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/enumWhen/declSite.kt"); + } + + @TestMetadata("declSiteSeveralMappings.kt") + public void testDeclSiteSeveralMappings() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/enumWhen/declSiteSeveralMappings.kt"); + } + + @TestMetadata("declSiteSeveralMappingsDifOrder.kt") + public void testDeclSiteSeveralMappingsDifOrder() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/enumWhen/declSiteSeveralMappingsDifOrder.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ProperRecapturing extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInProperRecapturing() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("inlineChain.kt") + public void testInlineChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing/inlineChain.kt"); + } + + @TestMetadata("lambdaChain.kt") + public void testLambdaChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing/lambdaChain.kt"); + } + + @TestMetadata("lambdaChainSimple.kt") + public void testLambdaChainSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing/lambdaChainSimple.kt"); + } + + @TestMetadata("lambdaChain_2.kt") + public void testLambdaChain_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing/lambdaChain_2.kt"); + } + + @TestMetadata("lambdaChain_3.kt") + public void testLambdaChain_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing/lambdaChain_3.kt"); + } + + @TestMetadata("noInlineLambda.kt") + public void testNoInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing/noInlineLambda.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ProperRecapturingInClass extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInProperRecapturingInClass() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("inlineChain.kt") + public void testInlineChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/inlineChain.kt"); + } + + @TestMetadata("inlinelambdaChain.kt") + public void testInlinelambdaChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/inlinelambdaChain.kt"); + } + + @TestMetadata("lambdaChain.kt") + public void testLambdaChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/lambdaChain.kt"); + } + + @TestMetadata("lambdaChainSimple.kt") + public void testLambdaChainSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/lambdaChainSimple.kt"); + } + + @TestMetadata("lambdaChainSimple_2.kt") + public void testLambdaChainSimple_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/lambdaChainSimple_2.kt"); + } + + @TestMetadata("lambdaChain_2.kt") + public void testLambdaChain_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/lambdaChain_2.kt"); + } + + @TestMetadata("lambdaChain_3.kt") + public void testLambdaChain_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/lambdaChain_3.kt"); + } + + @TestMetadata("noCapturedThisOnCallSite.kt") + public void testNoCapturedThisOnCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/noCapturedThisOnCallSite.kt"); + } + + @TestMetadata("noInlineLambda.kt") + public void testNoInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/noInlineLambda.kt"); + } + + @TestMetadata("twoInlineLambda.kt") + public void testTwoInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/twoInlineLambda.kt"); + } + + @TestMetadata("twoInlineLambdaComplex.kt") + public void testTwoInlineLambdaComplex() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/twoInlineLambdaComplex.kt"); + } + + @TestMetadata("twoInlineLambdaComplex_2.kt") + public void testTwoInlineLambdaComplex_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/twoInlineLambdaComplex_2.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject/sam") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Sam extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInSam() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("anonymousObjectToSam.kt") + public void testAnonymousObjectToSam() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/sam/anonymousObjectToSam.kt"); + } + + @TestMetadata("kt17091.kt") + public void testKt17091() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/sam/kt17091.kt"); + } + + @TestMetadata("kt21671.kt") + public void testKt21671() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/sam/kt21671.kt"); + } + + @TestMetadata("kt21671_2.kt") + public void testKt21671_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/sam/kt21671_2.kt"); + } + + @TestMetadata("kt21671_3.kt") + public void testKt21671_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/sam/kt21671_3.kt"); + } + + @TestMetadata("kt22304.kt") + public void testKt22304() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/sam/kt22304.kt"); + } + + @TestMetadata("samOnCallSite.kt") + public void testSamOnCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/sam/samOnCallSite.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TwoCapturedReceivers extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInTwoCapturedReceivers() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("kt8668.kt") + public void testKt8668() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers/kt8668.kt"); + } + + @TestMetadata("kt8668_2.kt") + public void testKt8668_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers/kt8668_2.kt"); + } + + @TestMetadata("kt8668_3.kt") + public void testKt8668_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers/kt8668_3.kt"); + } + + @TestMetadata("twoDifferentDispatchReceivers.kt") + public void testTwoDifferentDispatchReceivers() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers/twoDifferentDispatchReceivers.kt"); + } + + @TestMetadata("twoExtensionReceivers.kt") + public void testTwoExtensionReceivers() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers/twoExtensionReceivers.kt"); + } + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/argumentOrder") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ArgumentOrder extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInArgumentOrder() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("boundFunctionReference.kt") + public void testBoundFunctionReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/boundFunctionReference.kt"); + } + + @TestMetadata("boundFunctionReference2.kt") + public void testBoundFunctionReference2() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/boundFunctionReference2.kt"); + } + + @TestMetadata("captured.kt") + public void testCaptured() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/captured.kt"); + } + + @TestMetadata("capturedInExtension.kt") + public void testCapturedInExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/capturedInExtension.kt"); + } + + @TestMetadata("defaultParametersAndLastVararg.kt") + public void testDefaultParametersAndLastVararg() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/defaultParametersAndLastVararg.kt"); + } + + @TestMetadata("extension.kt") + public void testExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/extension.kt"); + } + + @TestMetadata("extensionInClass.kt") + public void testExtensionInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/extensionInClass.kt"); + } + + @TestMetadata("lambdaMigration.kt") + public void testLambdaMigration() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/lambdaMigration.kt"); + } + + @TestMetadata("lambdaMigrationInClass.kt") + public void testLambdaMigrationInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/lambdaMigrationInClass.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/simple.kt"); + } + + @TestMetadata("simpleInClass.kt") + public void testSimpleInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/simpleInClass.kt"); + } + + @TestMetadata("varargAndDefaultParameters.kt") + public void testVarargAndDefaultParameters() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/varargAndDefaultParameters.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/arrayConvention") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ArrayConvention extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInArrayConvention() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/arrayConvention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("simpleAccess.kt") + public void testSimpleAccess() throws Exception { + runTest("compiler/testData/codegen/boxInline/arrayConvention/simpleAccess.kt"); + } + + @TestMetadata("simpleAccessInClass.kt") + public void testSimpleAccessInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/arrayConvention/simpleAccessInClass.kt"); + } + + @TestMetadata("simpleAccessWithDefault.kt") + public void testSimpleAccessWithDefault() throws Exception { + runTest("compiler/testData/codegen/boxInline/arrayConvention/simpleAccessWithDefault.kt"); + } + + @TestMetadata("simpleAccessWithDefaultInClass.kt") + public void testSimpleAccessWithDefaultInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/arrayConvention/simpleAccessWithDefaultInClass.kt"); + } + + @TestMetadata("simpleAccessWithLambda.kt") + public void testSimpleAccessWithLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/arrayConvention/simpleAccessWithLambda.kt"); + } + + @TestMetadata("simpleAccessWithLambdaInClass.kt") + public void testSimpleAccessWithLambdaInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/arrayConvention/simpleAccessWithLambdaInClass.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/assert") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Assert extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInAssert() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("jvmAssertInlineFunctionAssertionsDisabled.kt") + public void testJvmAssertInlineFunctionAssertionsDisabled() throws Exception { + runTest("compiler/testData/codegen/boxInline/assert/jvmAssertInlineFunctionAssertionsDisabled.kt"); + } + + @TestMetadata("jvmAssertInlineFunctionAssertionsEnabled.kt") + public void testJvmAssertInlineFunctionAssertionsEnabled() throws Exception { + runTest("compiler/testData/codegen/boxInline/assert/jvmAssertInlineFunctionAssertionsEnabled.kt"); + } + + @TestMetadata("jvmAssertInlineLambda.kt") + public void testJvmAssertInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/assert/jvmAssertInlineLambda.kt"); + } + + @TestMetadata("jvmClassInitializer.kt") + public void testJvmClassInitializer() throws Exception { + runTest("compiler/testData/codegen/boxInline/assert/jvmClassInitializer.kt"); + } + + @TestMetadata("jvmCompanion.kt") + public void testJvmCompanion() throws Exception { + runTest("compiler/testData/codegen/boxInline/assert/jvmCompanion.kt"); + } + + @TestMetadata("jvmCrossinlineLambda.kt") + public void testJvmCrossinlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/assert/jvmCrossinlineLambda.kt"); + } + + @TestMetadata("jvmCrossinlineLambda2.kt") + public void testJvmCrossinlineLambda2() throws Exception { + runTest("compiler/testData/codegen/boxInline/assert/jvmCrossinlineLambda2.kt"); + } + + @TestMetadata("jvmCrossinlineLambdaDeclarationSite.kt") + public void testJvmCrossinlineLambdaDeclarationSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/assert/jvmCrossinlineLambdaDeclarationSite.kt"); + } + + @TestMetadata("jvmCrossinlineLambdaDeclarationSiteOnly.kt") + public void testJvmCrossinlineLambdaDeclarationSiteOnly() throws Exception { + runTest("compiler/testData/codegen/boxInline/assert/jvmCrossinlineLambdaDeclarationSiteOnly.kt"); + } + + @TestMetadata("jvmCrossinlineSAMDeclarationSite.kt") + public void testJvmCrossinlineSAMDeclarationSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/assert/jvmCrossinlineSAMDeclarationSite.kt"); + } + + @TestMetadata("jvmDoubleInline.kt") + public void testJvmDoubleInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/assert/jvmDoubleInline.kt"); + } + + @TestMetadata("jvmInlineUsedAsNoinline.kt") + public void testJvmInlineUsedAsNoinline() throws Exception { + runTest("compiler/testData/codegen/boxInline/assert/jvmInlineUsedAsNoinline.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/builders") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Builders extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInBuilders() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/builders"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("builders.kt") + public void testBuilders() throws Exception { + runTest("compiler/testData/codegen/boxInline/builders/builders.kt"); + } + + @TestMetadata("buildersAndLambdaCapturing.kt") + public void testBuildersAndLambdaCapturing() throws Exception { + runTest("compiler/testData/codegen/boxInline/builders/buildersAndLambdaCapturing.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/bytecodePreprocessing") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class BytecodePreprocessing extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInBytecodePreprocessing() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/bytecodePreprocessing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("apiVersionAtLeast1.kt") + public void testApiVersionAtLeast1() throws Exception { + runTest("compiler/testData/codegen/boxInline/bytecodePreprocessing/apiVersionAtLeast1.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/callableReference") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CallableReference extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInCallableReference() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("classLevel.kt") + public void testClassLevel() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/classLevel.kt"); + } + + @TestMetadata("classLevel2.kt") + public void testClassLevel2() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/classLevel2.kt"); + } + + @TestMetadata("constructor.kt") + public void testConstructor() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/constructor.kt"); + } + + @TestMetadata("innerGenericConstuctor.kt") + public void testInnerGenericConstuctor() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/innerGenericConstuctor.kt"); + } + + @TestMetadata("intrinsic.kt") + public void testIntrinsic() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/intrinsic.kt"); + } + + @TestMetadata("jvmFieldProperty.kt") + public void testJvmFieldProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/jvmFieldProperty.kt"); + } + + @TestMetadata("kt15449.kt") + public void testKt15449() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/kt15449.kt"); + } + + @TestMetadata("kt15751_2.kt") + public void testKt15751_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/kt15751_2.kt"); + } + + @TestMetadata("kt16411.kt") + public void testKt16411() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/kt16411.kt"); + } + + @TestMetadata("kt35101.kt") + public void testKt35101() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/kt35101.kt"); + } + + @TestMetadata("propertyIntrinsic.kt") + public void testPropertyIntrinsic() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/propertyIntrinsic.kt"); + } + + @TestMetadata("propertyReference.kt") + public void testPropertyReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/propertyReference.kt"); + } + + @TestMetadata("topLevel.kt") + public void testTopLevel() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/topLevel.kt"); + } + + @TestMetadata("topLevelExtension.kt") + public void testTopLevelExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/topLevelExtension.kt"); + } + + @TestMetadata("topLevelProperty.kt") + public void testTopLevelProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/topLevelProperty.kt"); + } + + @TestMetadata("compiler/testData/codegen/boxInline/callableReference/bound") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Bound extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInBound() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("classProperty.kt") + public void testClassProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/classProperty.kt"); + } + + @TestMetadata("emptyLhsFunction.kt") + public void testEmptyLhsFunction() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/emptyLhsFunction.kt"); + } + + @TestMetadata("emptyLhsOnInlineProperty.kt") + public void testEmptyLhsOnInlineProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/emptyLhsOnInlineProperty.kt"); + } + + @TestMetadata("emptyLhsProperty.kt") + public void testEmptyLhsProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/emptyLhsProperty.kt"); + } + + @TestMetadata("expression.kt") + public void testExpression() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/expression.kt"); + } + + @TestMetadata("extensionReceiver.kt") + public void testExtensionReceiver() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/extensionReceiver.kt"); + } + + @TestMetadata("filter.kt") + public void testFilter() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/filter.kt"); + } + + @TestMetadata("inlineValueParameterInsteadOfReceiver.kt") + public void testInlineValueParameterInsteadOfReceiver() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/inlineValueParameterInsteadOfReceiver.kt"); + } + + @TestMetadata("innerGenericConstuctor.kt") + public void testInnerGenericConstuctor() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/innerGenericConstuctor.kt"); + } + + @TestMetadata("intrinsic.kt") + public void testIntrinsic() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/intrinsic.kt"); + } + + @TestMetadata("jvmFieldProperty.kt") + public void testJvmFieldProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/jvmFieldProperty.kt"); + } + + @TestMetadata("kt18728.kt") + public void testKt18728() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/kt18728.kt"); + } + + @TestMetadata("kt18728_2.kt") + public void testKt18728_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/kt18728_2.kt"); + } + + @TestMetadata("kt18728_3.kt") + public void testKt18728_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/kt18728_3.kt"); + } + + @TestMetadata("kt18728_4.kt") + public void testKt18728_4() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/kt18728_4.kt"); + } + + @TestMetadata("map.kt") + public void testMap() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/map.kt"); + } + + @TestMetadata("mixed.kt") + public void testMixed() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/mixed.kt"); + } + + @TestMetadata("objectProperty.kt") + public void testObjectProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/objectProperty.kt"); + } + + @TestMetadata("propertyImportedFromObject.kt") + public void testPropertyImportedFromObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/propertyImportedFromObject.kt"); + } + + @TestMetadata("sideEffect.kt") + public void testSideEffect() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/sideEffect.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/simple.kt"); + } + + @TestMetadata("simpleVal.kt") + public void testSimpleVal() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/simpleVal.kt"); + } + + @TestMetadata("simpleVal2.kt") + public void testSimpleVal2() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/simpleVal2.kt"); + } + + @TestMetadata("topLevelExtensionProperty.kt") + public void testTopLevelExtensionProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/topLevelExtensionProperty.kt"); + } + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/capture") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Capture extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInCapture() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/capture"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("captureInlinable.kt") + public void testCaptureInlinable() throws Exception { + runTest("compiler/testData/codegen/boxInline/capture/captureInlinable.kt"); + } + + @TestMetadata("captureInlinableAndOther.kt") + public void testCaptureInlinableAndOther() throws Exception { + runTest("compiler/testData/codegen/boxInline/capture/captureInlinableAndOther.kt"); + } + + @TestMetadata("captureThisAndReceiver.kt") + public void testCaptureThisAndReceiver() throws Exception { + runTest("compiler/testData/codegen/boxInline/capture/captureThisAndReceiver.kt"); + } + + @TestMetadata("generics.kt") + public void testGenerics() throws Exception { + runTest("compiler/testData/codegen/boxInline/capture/generics.kt"); + } + + @TestMetadata("simpleCapturingInClass.kt") + public void testSimpleCapturingInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/capture/simpleCapturingInClass.kt"); + } + + @TestMetadata("simpleCapturingInPackage.kt") + public void testSimpleCapturingInPackage() throws Exception { + runTest("compiler/testData/codegen/boxInline/capture/simpleCapturingInPackage.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/complex") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Complex extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInComplex() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("closureChain.kt") + public void testClosureChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/complex/closureChain.kt"); + } + + @TestMetadata("forEachLine.kt") + public void testForEachLine() throws Exception { + runTest("compiler/testData/codegen/boxInline/complex/forEachLine.kt"); + } + + @TestMetadata("lambdaInLambda.kt") + public void testLambdaInLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/complex/lambdaInLambda.kt"); + } + + @TestMetadata("swapAndWith.kt") + public void testSwapAndWith() throws Exception { + runTest("compiler/testData/codegen/boxInline/complex/swapAndWith.kt"); + } + + @TestMetadata("swapAndWith2.kt") + public void testSwapAndWith2() throws Exception { + runTest("compiler/testData/codegen/boxInline/complex/swapAndWith2.kt"); + } + + @TestMetadata("use.kt") + public void testUse() throws Exception { + runTest("compiler/testData/codegen/boxInline/complex/use.kt"); + } + + @TestMetadata("with.kt") + public void testWith() throws Exception { + runTest("compiler/testData/codegen/boxInline/complex/with.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/complexStack") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ComplexStack extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInComplexStack() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complexStack"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("asCheck.kt") + public void testAsCheck() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/asCheck.kt"); + } + + @TestMetadata("asCheck2.kt") + public void testAsCheck2() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/asCheck2.kt"); + } + + @TestMetadata("breakContinueInInlineLambdaArgument.kt") + public void testBreakContinueInInlineLambdaArgument() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/breakContinueInInlineLambdaArgument.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/simple.kt"); + } + + @TestMetadata("simple2.kt") + public void testSimple2() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/simple2.kt"); + } + + @TestMetadata("simple3.kt") + public void testSimple3() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/simple3.kt"); + } + + @TestMetadata("simple4.kt") + public void testSimple4() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/simple4.kt"); + } + + @TestMetadata("simpleExtension.kt") + public void testSimpleExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/simpleExtension.kt"); + } + + @TestMetadata("spillConstructorArgumentsAndInlineLambdaParameter.kt") + public void testSpillConstructorArgumentsAndInlineLambdaParameter() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/spillConstructorArgumentsAndInlineLambdaParameter.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/contracts") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Contracts extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInContracts() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("cfgDependendValInitialization.kt") + public void testCfgDependendValInitialization() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/cfgDependendValInitialization.kt"); + } + + @TestMetadata("complexInitializer.kt") + public void testComplexInitializer() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/complexInitializer.kt"); + } + + @TestMetadata("complexInitializerWithStackTransformation.kt") + public void testComplexInitializerWithStackTransformation() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/complexInitializerWithStackTransformation.kt"); + } + + @TestMetadata("crossinlineCallableReference.kt") + public void testCrossinlineCallableReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/crossinlineCallableReference.kt"); + } + + @TestMetadata("definiteLongValInitialization.kt") + public void testDefiniteLongValInitialization() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/definiteLongValInitialization.kt"); + } + + @TestMetadata("definiteNestedValInitialization.kt") + public void testDefiniteNestedValInitialization() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/definiteNestedValInitialization.kt"); + } + + @TestMetadata("definiteValInitInInitializer.kt") + public void testDefiniteValInitInInitializer() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/definiteValInitInInitializer.kt"); + } + + @TestMetadata("definiteValInitialization.kt") + public void testDefiniteValInitialization() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/definiteValInitialization.kt"); + } + + @TestMetadata("exactlyOnceCrossinline.kt") + public void testExactlyOnceCrossinline() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/exactlyOnceCrossinline.kt"); + } + + @TestMetadata("exactlyOnceCrossinline2.kt") + public void testExactlyOnceCrossinline2() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/exactlyOnceCrossinline2.kt"); + } + + @TestMetadata("exactlyOnceNoinline.kt") + public void testExactlyOnceNoinline() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/exactlyOnceNoinline.kt"); + } + + @TestMetadata("nonLocalReturn.kt") + public void testNonLocalReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/nonLocalReturn.kt"); + } + + @TestMetadata("nonLocalReturnWithCycle.kt") + public void testNonLocalReturnWithCycle() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/nonLocalReturnWithCycle.kt"); + } + + @TestMetadata("propertyInitialization.kt") + public void testPropertyInitialization() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/propertyInitialization.kt"); + } + + @TestMetadata("valInitializationAndUsageInNestedLambda.kt") + public void testValInitializationAndUsageInNestedLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/valInitializationAndUsageInNestedLambda.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/defaultValues") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DefaultValues extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + @TestMetadata("33Parameters.kt") + public void test33Parameters() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/33Parameters.kt"); + } + + @TestMetadata("33ParametersInConstructor.kt") + public void test33ParametersInConstructor() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/33ParametersInConstructor.kt"); + } + + public void testAllFilesPresentInDefaultValues() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("defaultInExtension.kt") + public void testDefaultInExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/defaultInExtension.kt"); + } + + @TestMetadata("defaultMethod.kt") + public void testDefaultMethod() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/defaultMethod.kt"); + } + + @TestMetadata("defaultMethodInClass.kt") + public void testDefaultMethodInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/defaultMethodInClass.kt"); + } + + @TestMetadata("defaultParamRemapping.kt") + public void testDefaultParamRemapping() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/defaultParamRemapping.kt"); + } + + @TestMetadata("inlineInDefaultParameter.kt") + public void testInlineInDefaultParameter() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/inlineInDefaultParameter.kt"); + } + + @TestMetadata("inlineLambdaInNoInlineDefault.kt") + public void testInlineLambdaInNoInlineDefault() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/inlineLambdaInNoInlineDefault.kt"); + } + + @TestMetadata("kt11479.kt") + public void testKt11479() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt11479.kt"); + } + + @TestMetadata("kt11479InlinedDefaultParameter.kt") + public void testKt11479InlinedDefaultParameter() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt11479InlinedDefaultParameter.kt"); + } + + @TestMetadata("kt14564.kt") + public void testKt14564() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt14564.kt"); + } + + @TestMetadata("kt14564_2.kt") + public void testKt14564_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt14564_2.kt"); + } + + @TestMetadata("kt16496.kt") + public void testKt16496() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt16496.kt"); + } + + @TestMetadata("kt18689.kt") + public void testKt18689() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt18689.kt"); + } + + @TestMetadata("kt18689_2.kt") + public void testKt18689_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt18689_2.kt"); + } + + @TestMetadata("kt18689_3.kt") + public void testKt18689_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt18689_3.kt"); + } + + @TestMetadata("kt18689_4.kt") + public void testKt18689_4() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt18689_4.kt"); + } + + @TestMetadata("kt5685.kt") + public void testKt5685() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt5685.kt"); + } + + @TestMetadata("simpleDefaultMethod.kt") + public void testSimpleDefaultMethod() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/simpleDefaultMethod.kt"); + } + + @TestMetadata("varArgNoInline.kt") + public void testVarArgNoInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/varArgNoInline.kt"); + } + + @TestMetadata("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class LambdaInlining extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInLambdaInlining() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("checkLambdaClassIsPresent.kt") + public void testCheckLambdaClassIsPresent() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/checkLambdaClassIsPresent.kt"); + } + + @TestMetadata("checkLambdaClassesArePresent.kt") + public void testCheckLambdaClassesArePresent() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/checkLambdaClassesArePresent.kt"); + } + + @TestMetadata("checkObjectClassIsPresent.kt") + public void testCheckObjectClassIsPresent() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/checkObjectClassIsPresent.kt"); + } + + @TestMetadata("checkStaticLambdaClassIsPresent.kt") + public void testCheckStaticLambdaClassIsPresent() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/checkStaticLambdaClassIsPresent.kt"); + } + + @TestMetadata("checkStaticLambdaClassesArePresent.kt") + public void testCheckStaticLambdaClassesArePresent() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/checkStaticLambdaClassesArePresent.kt"); + } + + @TestMetadata("checkStaticObjectClassIsPresent.kt") + public void testCheckStaticObjectClassIsPresent() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/checkStaticObjectClassIsPresent.kt"); + } + + @TestMetadata("defaultCallInDefaultLambda.kt") + public void testDefaultCallInDefaultLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/defaultCallInDefaultLambda.kt"); + } + + @TestMetadata("defaultLambdaInNoInline.kt") + public void testDefaultLambdaInNoInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/defaultLambdaInNoInline.kt"); + } + + @TestMetadata("differentInvokeSignature.kt") + public void testDifferentInvokeSignature() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/differentInvokeSignature.kt"); + } + + @TestMetadata("genericLambda.kt") + public void testGenericLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/genericLambda.kt"); + } + + @TestMetadata("instanceCapturedInClass.kt") + public void testInstanceCapturedInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/instanceCapturedInClass.kt"); + } + + @TestMetadata("instanceCapturedInInterface.kt") + public void testInstanceCapturedInInterface() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/instanceCapturedInInterface.kt"); + } + + @TestMetadata("jvmStaticDefault.kt") + public void testJvmStaticDefault() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/jvmStaticDefault.kt"); + } + + @TestMetadata("kt21827.kt") + public void testKt21827() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/kt21827.kt"); + } + + @TestMetadata("kt21946.kt") + public void testKt21946() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/kt21946.kt"); + } + + @TestMetadata("kt24477.kt") + public void testKt24477() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/kt24477.kt"); + } + + @TestMetadata("kt25106.kt") + public void testKt25106() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/kt25106.kt"); + } + + @TestMetadata("kt26636.kt") + public void testKt26636() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/kt26636.kt"); + } + + @TestMetadata("noInline.kt") + public void testNoInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/noInline.kt"); + } + + @TestMetadata("nonDefaultInlineInNoInline.kt") + public void testNonDefaultInlineInNoInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/nonDefaultInlineInNoInline.kt"); + } + + @TestMetadata("receiverClash.kt") + public void testReceiverClash() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/receiverClash.kt"); + } + + @TestMetadata("receiverClash2.kt") + public void testReceiverClash2() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/receiverClash2.kt"); + } + + @TestMetadata("receiverClashInClass.kt") + public void testReceiverClashInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/receiverClashInClass.kt"); + } + + @TestMetadata("receiverClashInClass2.kt") + public void testReceiverClashInClass2() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/receiverClashInClass2.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/simple.kt"); + } + + @TestMetadata("simpleErased.kt") + public void testSimpleErased() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/simpleErased.kt"); + } + + @TestMetadata("simpleErasedStaticInstance.kt") + public void testSimpleErasedStaticInstance() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/simpleErasedStaticInstance.kt"); + } + + @TestMetadata("simpleExtension.kt") + public void testSimpleExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/simpleExtension.kt"); + } + + @TestMetadata("simpleGeneric.kt") + public void testSimpleGeneric() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/simpleGeneric.kt"); + } + + @TestMetadata("simpleStaticInstance.kt") + public void testSimpleStaticInstance() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/simpleStaticInstance.kt"); + } + + @TestMetadata("thisClash.kt") + public void testThisClash() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/thisClash.kt"); + } + + @TestMetadata("thisClashInClass.kt") + public void testThisClashInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/thisClashInClass.kt"); + } + + @TestMetadata("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CallableReferences extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInCallableReferences() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("boundFunctionReference.kt") + public void testBoundFunctionReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundFunctionReference.kt"); + } + + @TestMetadata("boundFunctionReferenceOnInt.kt") + public void testBoundFunctionReferenceOnInt() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundFunctionReferenceOnInt.kt"); + } + + @TestMetadata("boundFunctionReferenceOnLong.kt") + public void testBoundFunctionReferenceOnLong() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundFunctionReferenceOnLong.kt"); + } + + @TestMetadata("boundPropertyReference.kt") + public void testBoundPropertyReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundPropertyReference.kt"); + } + + @TestMetadata("boundPropertyReferenceOnInt.kt") + public void testBoundPropertyReferenceOnInt() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundPropertyReferenceOnInt.kt"); + } + + @TestMetadata("boundPropertyReferenceOnLong.kt") + public void testBoundPropertyReferenceOnLong() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundPropertyReferenceOnLong.kt"); + } + + @TestMetadata("constuctorReference.kt") + public void testConstuctorReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/constuctorReference.kt"); + } + + @TestMetadata("differentInvokeSignature.kt") + public void testDifferentInvokeSignature() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/differentInvokeSignature.kt"); + } + + @TestMetadata("differentInvokeSignature2.kt") + public void testDifferentInvokeSignature2() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/differentInvokeSignature2.kt"); + } + + @TestMetadata("functionImportedFromObject.kt") + public void testFunctionImportedFromObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/functionImportedFromObject.kt"); + } + + @TestMetadata("functionReference.kt") + public void testFunctionReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/functionReference.kt"); + } + + @TestMetadata("functionReferenceFromClass.kt") + public void testFunctionReferenceFromClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/functionReferenceFromClass.kt"); + } + + @TestMetadata("functionReferenceFromObject.kt") + public void testFunctionReferenceFromObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/functionReferenceFromObject.kt"); + } + + @TestMetadata("innerClassConstuctorReference.kt") + public void testInnerClassConstuctorReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/innerClassConstuctorReference.kt"); + } + + @TestMetadata("mutableBoundPropertyReferenceFromClass.kt") + public void testMutableBoundPropertyReferenceFromClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/mutableBoundPropertyReferenceFromClass.kt"); + } + + @TestMetadata("mutablePropertyReferenceFromClass.kt") + public void testMutablePropertyReferenceFromClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/mutablePropertyReferenceFromClass.kt"); + } + + @TestMetadata("privateFunctionReference.kt") + public void testPrivateFunctionReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/privateFunctionReference.kt"); + } + + @TestMetadata("privatePropertyReference.kt") + public void testPrivatePropertyReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/privatePropertyReference.kt"); + } + + @TestMetadata("propertyImportedFromObject.kt") + public void testPropertyImportedFromObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/propertyImportedFromObject.kt"); + } + + @TestMetadata("propertyReference.kt") + public void testPropertyReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/propertyReference.kt"); + } + + @TestMetadata("propertyReferenceFromClass.kt") + public void testPropertyReferenceFromClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/propertyReferenceFromClass.kt"); + } + + @TestMetadata("propertyReferenceFromObject.kt") + public void testPropertyReferenceFromObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/propertyReferenceFromObject.kt"); + } + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/defaultValues/maskElimination") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MaskElimination extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + @TestMetadata("32Parameters.kt") + public void test32Parameters() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/32Parameters.kt"); + } + + @TestMetadata("33Parameters.kt") + public void test33Parameters() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/33Parameters.kt"); + } + + public void testAllFilesPresentInMaskElimination() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/maskElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("kt18792.kt") + public void testKt18792() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/kt18792.kt"); + } + + @TestMetadata("kt19679.kt") + public void testKt19679() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/kt19679.kt"); + } + + @TestMetadata("kt19679_2.kt") + public void testKt19679_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/kt19679_2.kt"); + } + + @TestMetadata("kt19679_3.kt") + public void testKt19679_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/kt19679_3.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/simple.kt"); + } + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/delegatedProperty") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DelegatedProperty extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInDelegatedProperty() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("kt16864.kt") + public void testKt16864() throws Exception { + runTest("compiler/testData/codegen/boxInline/delegatedProperty/kt16864.kt"); + } + + @TestMetadata("local.kt") + public void testLocal() throws Exception { + runTest("compiler/testData/codegen/boxInline/delegatedProperty/local.kt"); + } + + @TestMetadata("localInAnonymousObject.kt") + public void testLocalInAnonymousObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/delegatedProperty/localInAnonymousObject.kt"); + } + + @TestMetadata("localInLambda.kt") + public void testLocalInLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/delegatedProperty/localInLambda.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/enclosingInfo") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class EnclosingInfo extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInEnclosingInfo() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("anonymousInLambda.kt") + public void testAnonymousInLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/enclosingInfo/anonymousInLambda.kt"); + } + + @TestMetadata("inlineChain.kt") + public void testInlineChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/enclosingInfo/inlineChain.kt"); + } + + @TestMetadata("inlineChain2.kt") + public void testInlineChain2() throws Exception { + runTest("compiler/testData/codegen/boxInline/enclosingInfo/inlineChain2.kt"); + } + + @TestMetadata("objectInInlineFun.kt") + public void testObjectInInlineFun() throws Exception { + runTest("compiler/testData/codegen/boxInline/enclosingInfo/objectInInlineFun.kt"); + } + + @TestMetadata("transformedConstructor.kt") + public void testTransformedConstructor() throws Exception { + runTest("compiler/testData/codegen/boxInline/enclosingInfo/transformedConstructor.kt"); + } + + @TestMetadata("transformedConstructorWithAdditionalObject.kt") + public void testTransformedConstructorWithAdditionalObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/enclosingInfo/transformedConstructorWithAdditionalObject.kt"); + } + + @TestMetadata("transformedConstructorWithNestedInline.kt") + public void testTransformedConstructorWithNestedInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/enclosingInfo/transformedConstructorWithNestedInline.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/enum") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Enum extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInEnum() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("kt10569.kt") + public void testKt10569() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/kt10569.kt"); + } + + @TestMetadata("kt18254.kt") + public void testKt18254() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/kt18254.kt"); + } + + @TestMetadata("valueOf.kt") + public void testValueOf() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valueOf.kt"); + } + + @TestMetadata("valueOfCapturedType.kt") + public void testValueOfCapturedType() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valueOfCapturedType.kt"); + } + + @TestMetadata("valueOfChain.kt") + public void testValueOfChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valueOfChain.kt"); + } + + @TestMetadata("valueOfChainCapturedType.kt") + public void testValueOfChainCapturedType() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valueOfChainCapturedType.kt"); + } + + @TestMetadata("valueOfNonReified.kt") + public void testValueOfNonReified() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valueOfNonReified.kt"); + } + + @TestMetadata("values.kt") + public void testValues() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/values.kt"); + } + + @TestMetadata("valuesAsArray.kt") + public void testValuesAsArray() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valuesAsArray.kt"); + } + + @TestMetadata("valuesCapturedType.kt") + public void testValuesCapturedType() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valuesCapturedType.kt"); + } + + @TestMetadata("valuesChain.kt") + public void testValuesChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valuesChain.kt"); + } + + @TestMetadata("valuesChainCapturedType.kt") + public void testValuesChainCapturedType() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valuesChainCapturedType.kt"); + } + + @TestMetadata("valuesNonReified.kt") + public void testValuesNonReified() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valuesNonReified.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/functionExpression") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class FunctionExpression extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInFunctionExpression() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("extension.kt") + public void testExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/functionExpression/extension.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/inlineClasses") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineClasses extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInInlineClasses() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("inlineClassWithInlineValReturningInlineClass.kt") + public void testInlineClassWithInlineValReturningInlineClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/inlineClassWithInlineValReturningInlineClass.kt"); + } + + @TestMetadata("inlineFunctionInsideInlineClassesBox.kt") + public void testInlineFunctionInsideInlineClassesBox() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/inlineFunctionInsideInlineClassesBox.kt"); + } + + @TestMetadata("noReturnTypeManglingFun.kt") + public void testNoReturnTypeManglingFun() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/noReturnTypeManglingFun.kt"); + } + + @TestMetadata("noReturnTypeManglingFunJvmName.kt") + public void testNoReturnTypeManglingFunJvmName() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/noReturnTypeManglingFunJvmName.kt"); + } + + @TestMetadata("noReturnTypeManglingVal.kt") + public void testNoReturnTypeManglingVal() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/noReturnTypeManglingVal.kt"); + } + + @TestMetadata("withReturnTypeManglingFun.kt") + public void testWithReturnTypeManglingFun() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/withReturnTypeManglingFun.kt"); + } + + @TestMetadata("withReturnTypeManglingFunJvmName.kt") + public void testWithReturnTypeManglingFunJvmName() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/withReturnTypeManglingFunJvmName.kt"); + } + + @TestMetadata("withReturnTypeManglingVal.kt") + public void testWithReturnTypeManglingVal() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/withReturnTypeManglingVal.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/innerClasses") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InnerClasses extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInInnerClasses() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("captureThisAndOuter.kt") + public void testCaptureThisAndOuter() throws Exception { + runTest("compiler/testData/codegen/boxInline/innerClasses/captureThisAndOuter.kt"); + } + + @TestMetadata("innerLambda.kt") + public void testInnerLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/innerClasses/innerLambda.kt"); + } + + @TestMetadata("kt10259.kt") + public void testKt10259() throws Exception { + runTest("compiler/testData/codegen/boxInline/innerClasses/kt10259.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/jvmPackageName") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class JvmPackageName extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInJvmPackageName() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/jvmPackageName/simple.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/lambdaClassClash") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class LambdaClassClash extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInLambdaClassClash() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaClassClash"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("lambdaClassClash.kt") + public void testLambdaClassClash() throws Exception { + runTest("compiler/testData/codegen/boxInline/lambdaClassClash/lambdaClassClash.kt"); + } + + @TestMetadata("noInlineLambdaX2.kt") + public void testNoInlineLambdaX2() throws Exception { + runTest("compiler/testData/codegen/boxInline/lambdaClassClash/noInlineLambdaX2.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/lambdaTransformation") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class LambdaTransformation extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInLambdaTransformation() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaTransformation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("lambdaCloning.kt") + public void testLambdaCloning() throws Exception { + runTest("compiler/testData/codegen/boxInline/lambdaTransformation/lambdaCloning.kt"); + } + + @TestMetadata("lambdaInLambda2.kt") + public void testLambdaInLambda2() throws Exception { + runTest("compiler/testData/codegen/boxInline/lambdaTransformation/lambdaInLambda2.kt"); + } + + @TestMetadata("lambdaInLambdaNoInline.kt") + public void testLambdaInLambdaNoInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/lambdaTransformation/lambdaInLambdaNoInline.kt"); + } + + @TestMetadata("regeneratedLambdaName.kt") + public void testRegeneratedLambdaName() throws Exception { + runTest("compiler/testData/codegen/boxInline/lambdaTransformation/regeneratedLambdaName.kt"); + } + + @TestMetadata("regeneratedLambdaName2.kt") + public void testRegeneratedLambdaName2() throws Exception { + runTest("compiler/testData/codegen/boxInline/lambdaTransformation/regeneratedLambdaName2.kt"); + } + + @TestMetadata("sameCaptured.kt") + public void testSameCaptured() throws Exception { + runTest("compiler/testData/codegen/boxInline/lambdaTransformation/sameCaptured.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/localFunInLambda") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class LocalFunInLambda extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInLocalFunInLambda() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/localFunInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("defaultParam.kt") + public void testDefaultParam() throws Exception { + runTest("compiler/testData/codegen/boxInline/localFunInLambda/defaultParam.kt"); + } + + @TestMetadata("lambdaInLambdaCapturesAnotherFun.kt") + public void testLambdaInLambdaCapturesAnotherFun() throws Exception { + runTest("compiler/testData/codegen/boxInline/localFunInLambda/lambdaInLambdaCapturesAnotherFun.kt"); + } + + @TestMetadata("localFunInLambda.kt") + public void testLocalFunInLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/localFunInLambda/localFunInLambda.kt"); + } + + @TestMetadata("localFunInLambdaCapturesAnotherFun.kt") + public void testLocalFunInLambdaCapturesAnotherFun() throws Exception { + runTest("compiler/testData/codegen/boxInline/localFunInLambda/localFunInLambdaCapturesAnotherFun.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/multiModule") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultiModule extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInMultiModule() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("tryCatchWithRecursiveInline.kt") + public void testTryCatchWithRecursiveInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/multiModule/tryCatchWithRecursiveInline.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/multifileClasses") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class MultifileClasses extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInMultifileClasses() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("defaultArguments.kt") + public void testDefaultArguments() throws Exception { + runTest("compiler/testData/codegen/boxInline/multifileClasses/defaultArguments.kt"); + } + + @TestMetadata("inlineFromOptimizedMultifileClass.kt") + public void testInlineFromOptimizedMultifileClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/multifileClasses/inlineFromOptimizedMultifileClass.kt"); + } + + @TestMetadata("inlineFromOtherPackage.kt") + public void testInlineFromOtherPackage() throws Exception { + runTest("compiler/testData/codegen/boxInline/multifileClasses/inlineFromOtherPackage.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/multiplatform") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Multiplatform extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInMultiplatform() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("compiler/testData/codegen/boxInline/multiplatform/defaultArguments") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DefaultArguments extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInDefaultArguments() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("receiversAndParametersInLambda.kt") + public void testReceiversAndParametersInLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/multiplatform/defaultArguments/receiversAndParametersInLambda.kt"); + } + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/noInline") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NoInline extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInNoInline() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/noInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("extensionReceiver.kt") + public void testExtensionReceiver() throws Exception { + runTest("compiler/testData/codegen/boxInline/noInline/extensionReceiver.kt"); + } + + @TestMetadata("lambdaAsGeneric.kt") + public void testLambdaAsGeneric() throws Exception { + runTest("compiler/testData/codegen/boxInline/noInline/lambdaAsGeneric.kt"); + } + + @TestMetadata("lambdaAsNonFunction.kt") + public void testLambdaAsNonFunction() throws Exception { + runTest("compiler/testData/codegen/boxInline/noInline/lambdaAsNonFunction.kt"); + } + + @TestMetadata("noInline.kt") + public void testNoInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/noInline/noInline.kt"); + } + + @TestMetadata("noInlineLambdaChain.kt") + public void testNoInlineLambdaChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/noInline/noInlineLambdaChain.kt"); + } + + @TestMetadata("noInlineLambdaChainWithCapturedInline.kt") + public void testNoInlineLambdaChainWithCapturedInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/noInline/noInlineLambdaChainWithCapturedInline.kt"); + } + + @TestMetadata("withoutInline.kt") + public void testWithoutInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/noInline/withoutInline.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class NonLocalReturns extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInNonLocalReturns() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("explicitLocalReturn.kt") + public void testExplicitLocalReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/explicitLocalReturn.kt"); + } + + @TestMetadata("fromInterfaceDefaultGetter.kt") + public void testFromInterfaceDefaultGetter() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/fromInterfaceDefaultGetter.kt"); + } + + @TestMetadata("justReturnInLambda.kt") + public void testJustReturnInLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/justReturnInLambda.kt"); + } + + @TestMetadata("kt5199.kt") + public void testKt5199() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/kt5199.kt"); + } + + @TestMetadata("kt8948.kt") + public void testKt8948() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/kt8948.kt"); + } + + @TestMetadata("kt8948v2.kt") + public void testKt8948v2() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/kt8948v2.kt"); + } + + @TestMetadata("nestedNonLocals.kt") + public void testNestedNonLocals() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/nestedNonLocals.kt"); + } + + @TestMetadata("noInlineLocalReturn.kt") + public void testNoInlineLocalReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/noInlineLocalReturn.kt"); + } + + @TestMetadata("nonLocalReturnFromOuterLambda.kt") + public void testNonLocalReturnFromOuterLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/nonLocalReturnFromOuterLambda.kt"); + } + + @TestMetadata("propertyAccessors.kt") + public void testPropertyAccessors() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/propertyAccessors.kt"); + } + + @TestMetadata("returnFromFunctionExpr.kt") + public void testReturnFromFunctionExpr() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/returnFromFunctionExpr.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/simple.kt"); + } + + @TestMetadata("simpleFunctional.kt") + public void testSimpleFunctional() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/simpleFunctional.kt"); + } + + @TestMetadata("simpleVoid.kt") + public void testSimpleVoid() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/simpleVoid.kt"); + } + + @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Deparenthesize extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInDeparenthesize() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("bracket.kt") + public void testBracket() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize/bracket.kt"); + } + + @TestMetadata("labeled.kt") + public void testLabeled() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize/labeled.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TryFinally extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInTryFinally() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("kt16417.kt") + public void testKt16417() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt16417.kt"); + } + + @TestMetadata("kt20433.kt") + public void testKt20433() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt20433.kt"); + } + + @TestMetadata("kt20433_2.kt") + public void testKt20433_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt20433_2.kt"); + } + + @TestMetadata("kt20433_2_void.kt") + public void testKt20433_2_void() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt20433_2_void.kt"); + } + + @TestMetadata("kt20433_void.kt") + public void testKt20433_void() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt20433_void.kt"); + } + + @TestMetadata("kt26384.kt") + public void testKt26384() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt26384.kt"); + } + + @TestMetadata("kt26384_2.kt") + public void testKt26384_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt26384_2.kt"); + } + + @TestMetadata("kt28546.kt") + public void testKt28546() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt28546.kt"); + } + + @TestMetadata("kt6956.kt") + public void testKt6956() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt6956.kt"); + } + + @TestMetadata("kt7273.kt") + public void testKt7273() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt7273.kt"); + } + + @TestMetadata("nonLocalReturnFromCatchBlock.kt") + public void testNonLocalReturnFromCatchBlock() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/nonLocalReturnFromCatchBlock.kt"); + } + + @TestMetadata("nonLocalReturnFromOuterLambda.kt") + public void testNonLocalReturnFromOuterLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/nonLocalReturnFromOuterLambda.kt"); + } + + @TestMetadata("nonLocalReturnToCatchBlock.kt") + public void testNonLocalReturnToCatchBlock() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/nonLocalReturnToCatchBlock.kt"); + } + + @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CallSite extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInCallSite() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("callSite.kt") + public void testCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite/callSite.kt"); + } + + @TestMetadata("callSiteComplex.kt") + public void testCallSiteComplex() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite/callSiteComplex.kt"); + } + + @TestMetadata("exceptionTableSplit.kt") + public void testExceptionTableSplit() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite/exceptionTableSplit.kt"); + } + + @TestMetadata("exceptionTableSplitNoReturn.kt") + public void testExceptionTableSplitNoReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite/exceptionTableSplitNoReturn.kt"); + } + + @TestMetadata("finallyInFinally.kt") + public void testFinallyInFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite/finallyInFinally.kt"); + } + + @TestMetadata("wrongVarInterval.kt") + public void testWrongVarInterval() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite/wrongVarInterval.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Chained extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInChained() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("finallyInFinally.kt") + public void testFinallyInFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/finallyInFinally.kt"); + } + + @TestMetadata("finallyInFinally2.kt") + public void testFinallyInFinally2() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/finallyInFinally2.kt"); + } + + @TestMetadata("intReturn.kt") + public void testIntReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/intReturn.kt"); + } + + @TestMetadata("intReturnComplex.kt") + public void testIntReturnComplex() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/intReturnComplex.kt"); + } + + @TestMetadata("intReturnComplex2.kt") + public void testIntReturnComplex2() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/intReturnComplex2.kt"); + } + + @TestMetadata("intReturnComplex3.kt") + public void testIntReturnComplex3() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/intReturnComplex3.kt"); + } + + @TestMetadata("intReturnComplex4.kt") + public void testIntReturnComplex4() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/intReturnComplex4.kt"); + } + + @TestMetadata("nestedLambda.kt") + public void testNestedLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/nestedLambda.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DeclSite extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInDeclSite() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("complex.kt") + public void testComplex() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/complex.kt"); + } + + @TestMetadata("intReturn.kt") + public void testIntReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/intReturn.kt"); + } + + @TestMetadata("intReturnComplex.kt") + public void testIntReturnComplex() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/intReturnComplex.kt"); + } + + @TestMetadata("longReturn.kt") + public void testLongReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/longReturn.kt"); + } + + @TestMetadata("nested.kt") + public void testNested() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/nested.kt"); + } + + @TestMetadata("returnInFinally.kt") + public void testReturnInFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/returnInFinally.kt"); + } + + @TestMetadata("returnInTry.kt") + public void testReturnInTry() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/returnInTry.kt"); + } + + @TestMetadata("returnInTryAndFinally.kt") + public void testReturnInTryAndFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/returnInTryAndFinally.kt"); + } + + @TestMetadata("severalInTry.kt") + public void testSeveralInTry() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/severalInTry.kt"); + } + + @TestMetadata("severalInTryComplex.kt") + public void testSeveralInTryComplex() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/severalInTryComplex.kt"); + } + + @TestMetadata("voidInlineFun.kt") + public void testVoidInlineFun() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/voidInlineFun.kt"); + } + + @TestMetadata("voidNonLocal.kt") + public void testVoidNonLocal() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/voidNonLocal.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class ExceptionTable extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInExceptionTable() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("break.kt") + public void testBreak() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/break.kt"); + } + + @TestMetadata("continue.kt") + public void testContinue() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/continue.kt"); + } + + @TestMetadata("exceptionInFinally.kt") + public void testExceptionInFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/exceptionInFinally.kt"); + } + + @TestMetadata("forInFinally.kt") + public void testForInFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/forInFinally.kt"); + } + + @TestMetadata("innerAndExternal.kt") + public void testInnerAndExternal() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/innerAndExternal.kt"); + } + + @TestMetadata("innerAndExternalNested.kt") + public void testInnerAndExternalNested() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/innerAndExternalNested.kt"); + } + + @TestMetadata("innerAndExternalSimple.kt") + public void testInnerAndExternalSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/innerAndExternalSimple.kt"); + } + + @TestMetadata("kt31653.kt") + public void testKt31653() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/kt31653.kt"); + } + + @TestMetadata("kt31653_2.kt") + public void testKt31653_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/kt31653_2.kt"); + } + + @TestMetadata("kt31923.kt") + public void testKt31923() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/kt31923.kt"); + } + + @TestMetadata("kt31923_2.kt") + public void testKt31923_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/kt31923_2.kt"); + } + + @TestMetadata("kt31923_wrong.kt") + public void testKt31923_wrong() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/kt31923_wrong.kt"); + } + + @TestMetadata("nested.kt") + public void testNested() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/nested.kt"); + } + + @TestMetadata("nestedWithReturns.kt") + public void testNestedWithReturns() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/nestedWithReturns.kt"); + } + + @TestMetadata("nestedWithReturnsSimple.kt") + public void testNestedWithReturnsSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/nestedWithReturnsSimple.kt"); + } + + @TestMetadata("noFinally.kt") + public void testNoFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/noFinally.kt"); + } + + @TestMetadata("severalCatchClause.kt") + public void testSeveralCatchClause() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/severalCatchClause.kt"); + } + + @TestMetadata("simpleThrow.kt") + public void testSimpleThrow() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/simpleThrow.kt"); + } + + @TestMetadata("synchonized.kt") + public void testSynchonized() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/synchonized.kt"); + } + + @TestMetadata("throwInFinally.kt") + public void testThrowInFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/throwInFinally.kt"); + } + + @TestMetadata("tryCatchInFinally.kt") + public void testTryCatchInFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/tryCatchInFinally.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Variables extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInVariables() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("kt7792.kt") + public void testKt7792() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables/kt7792.kt"); + } + } + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/optimizations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Optimizations extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInOptimizations() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("kt20844.kt") + public void testKt20844() throws Exception { + runTest("compiler/testData/codegen/boxInline/optimizations/kt20844.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/private") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Private extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + @TestMetadata("accessorForConst.kt") + public void testAccessorForConst() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/accessorForConst.kt"); + } + + @TestMetadata("accessorStability.kt") + public void testAccessorStability() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/accessorStability.kt"); + } + + @TestMetadata("accessorStabilityInClass.kt") + public void testAccessorStabilityInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/accessorStabilityInClass.kt"); + } + + public void testAllFilesPresentInPrivate() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("effectivePrivate.kt") + public void testEffectivePrivate() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/effectivePrivate.kt"); + } + + @TestMetadata("kt6453.kt") + public void testKt6453() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/kt6453.kt"); + } + + @TestMetadata("kt8094.kt") + public void testKt8094() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/kt8094.kt"); + } + + @TestMetadata("kt8095.kt") + public void testKt8095() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/kt8095.kt"); + } + + @TestMetadata("nestedInPrivateClass.kt") + public void testNestedInPrivateClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/nestedInPrivateClass.kt"); + } + + @TestMetadata("privateClass.kt") + public void testPrivateClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/privateClass.kt"); + } + + @TestMetadata("privateClassExtensionLambda.kt") + public void testPrivateClassExtensionLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/privateClassExtensionLambda.kt"); + } + + @TestMetadata("privateInInlineInMultiFileFacade.kt") + public void testPrivateInInlineInMultiFileFacade() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/privateInInlineInMultiFileFacade.kt"); + } + + @TestMetadata("privateInline.kt") + public void testPrivateInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/privateInline.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/property") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Property extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInProperty() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("augAssignmentAndInc.kt") + public void testAugAssignmentAndInc() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/augAssignmentAndInc.kt"); + } + + @TestMetadata("augAssignmentAndIncInClass.kt") + public void testAugAssignmentAndIncInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/augAssignmentAndIncInClass.kt"); + } + + @TestMetadata("augAssignmentAndIncInClassViaConvention.kt") + public void testAugAssignmentAndIncInClassViaConvention() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/augAssignmentAndIncInClassViaConvention.kt"); + } + + @TestMetadata("augAssignmentAndIncOnExtension.kt") + public void testAugAssignmentAndIncOnExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/augAssignmentAndIncOnExtension.kt"); + } + + @TestMetadata("augAssignmentAndIncOnExtensionInClass.kt") + public void testAugAssignmentAndIncOnExtensionInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/augAssignmentAndIncOnExtensionInClass.kt"); + } + + @TestMetadata("augAssignmentAndIncViaConvention.kt") + public void testAugAssignmentAndIncViaConvention() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/augAssignmentAndIncViaConvention.kt"); + } + + @TestMetadata("fromObject.kt") + public void testFromObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/fromObject.kt"); + } + + @TestMetadata("kt22649.kt") + public void testKt22649() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/kt22649.kt"); + } + + @TestMetadata("property.kt") + public void testProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/property.kt"); + } + + @TestMetadata("reifiedVal.kt") + public void testReifiedVal() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/reifiedVal.kt"); + } + + @TestMetadata("reifiedVar.kt") + public void testReifiedVar() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/reifiedVar.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/simple.kt"); + } + + @TestMetadata("simpleExtension.kt") + public void testSimpleExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/simpleExtension.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/reified") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Reified extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInReified() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("arrayConstructor.kt") + public void testArrayConstructor() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/arrayConstructor.kt"); + } + + @TestMetadata("arrayOf.kt") + public void testArrayOf() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/arrayOf.kt"); + } + + @TestMetadata("capturedLambda.kt") + public void testCapturedLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/capturedLambda.kt"); + } + + @TestMetadata("capturedLambda2.kt") + public void testCapturedLambda2() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/capturedLambda2.kt"); + } + + @TestMetadata("kt11081.kt") + public void testKt11081() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt11081.kt"); + } + + @TestMetadata("kt11677.kt") + public void testKt11677() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt11677.kt"); + } + + @TestMetadata("kt15956.kt") + public void testKt15956() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt15956.kt"); + } + + @TestMetadata("kt15997.kt") + public void testKt15997() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt15997.kt"); + } + + @TestMetadata("kt15997_2.kt") + public void testKt15997_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt15997_2.kt"); + } + + @TestMetadata("kt18977.kt") + public void testKt18977() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt18977.kt"); + } + + @TestMetadata("kt6988.kt") + public void testKt6988() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt6988.kt"); + } + + @TestMetadata("kt6988_2.kt") + public void testKt6988_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt6988_2.kt"); + } + + @TestMetadata("kt6990.kt") + public void testKt6990() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt6990.kt"); + } + + @TestMetadata("kt7017.kt") + public void testKt7017() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt7017.kt"); + } + + @TestMetadata("kt8047.kt") + public void testKt8047() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt8047.kt"); + } + + @TestMetadata("kt8047_2.kt") + public void testKt8047_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt8047_2.kt"); + } + + @TestMetadata("kt9637.kt") + public void testKt9637() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt9637.kt"); + } + + @TestMetadata("kt9637_2.kt") + public void testKt9637_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt9637_2.kt"); + } + + @TestMetadata("nonCapturingObjectInLambda.kt") + public void testNonCapturingObjectInLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/nonCapturingObjectInLambda.kt"); + } + + @TestMetadata("packages.kt") + public void testPackages() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/packages.kt"); + } + + @TestMetadata("compiler/testData/codegen/boxInline/reified/checkCast") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CheckCast extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInCheckCast() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/checkCast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("chain.kt") + public void testChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/chain.kt"); + } + + @TestMetadata("kt26435.kt") + public void testKt26435() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/kt26435.kt"); + } + + @TestMetadata("kt26435_2.kt") + public void testKt26435_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/kt26435_2.kt"); + } + + @TestMetadata("kt26435_3.kt") + public void testKt26435_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/kt26435_3.kt"); + } + + @TestMetadata("kt8043.kt") + public void testKt8043() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/kt8043.kt"); + } + + @TestMetadata("maxStack.kt") + public void testMaxStack() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/maxStack.kt"); + } + + @TestMetadata("nullable.kt") + public void testNullable() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/nullable.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/simple.kt"); + } + + @TestMetadata("simpleSafe.kt") + public void testSimpleSafe() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/simpleSafe.kt"); + } + + @TestMetadata("simple_1_3.kt") + public void testSimple_1_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/simple_1_3.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/reified/defaultLambda") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DefaultLambda extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInDefaultLambda() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("chain.kt") + public void testChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/defaultLambda/chain.kt"); + } + + @TestMetadata("nested.kt") + public void testNested() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/defaultLambda/nested.kt"); + } + + @TestMetadata("nested2.kt") + public void testNested2() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/defaultLambda/nested2.kt"); + } + + @TestMetadata("nested2Static.kt") + public void testNested2Static() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/defaultLambda/nested2Static.kt"); + } + + @TestMetadata("nestedStatic.kt") + public void testNestedStatic() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/defaultLambda/nestedStatic.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/defaultLambda/simple.kt"); + } + + @TestMetadata("transitiveChain.kt") + public void testTransitiveChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/defaultLambda/transitiveChain.kt"); + } + + @TestMetadata("transitiveChainStatic.kt") + public void testTransitiveChainStatic() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/defaultLambda/transitiveChainStatic.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/reified/isCheck") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class IsCheck extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInIsCheck() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/isCheck"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("chain.kt") + public void testChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/isCheck/chain.kt"); + } + + @TestMetadata("nullable.kt") + public void testNullable() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/isCheck/nullable.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/isCheck/simple.kt"); + } + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/signature") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Signature extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInSignature() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("inProjectionSubstitution.kt") + public void testInProjectionSubstitution() throws Exception { + runTest("compiler/testData/codegen/boxInline/signature/inProjectionSubstitution.kt"); + } + + @TestMetadata("outProjectionSubstitution.kt") + public void testOutProjectionSubstitution() throws Exception { + runTest("compiler/testData/codegen/boxInline/signature/outProjectionSubstitution.kt"); + } + + @TestMetadata("recursion.kt") + public void testRecursion() throws Exception { + runTest("compiler/testData/codegen/boxInline/signature/recursion.kt"); + } + + @TestMetadata("sameFormalParameterName.kt") + public void testSameFormalParameterName() throws Exception { + runTest("compiler/testData/codegen/boxInline/signature/sameFormalParameterName.kt"); + } + + @TestMetadata("sameReifiedFormalParameterName.kt") + public void testSameReifiedFormalParameterName() throws Exception { + runTest("compiler/testData/codegen/boxInline/signature/sameReifiedFormalParameterName.kt"); + } + + @TestMetadata("starProjectionSubstitution.kt") + public void testStarProjectionSubstitution() throws Exception { + runTest("compiler/testData/codegen/boxInline/signature/starProjectionSubstitution.kt"); + } + + @TestMetadata("typeParameterInLambda.kt") + public void testTypeParameterInLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/signature/typeParameterInLambda.kt"); + } + + @TestMetadata("typeParametersSubstitution.kt") + public void testTypeParametersSubstitution() throws Exception { + runTest("compiler/testData/codegen/boxInline/signature/typeParametersSubstitution.kt"); + } + + @TestMetadata("typeParametersSubstitution2.kt") + public void testTypeParametersSubstitution2() throws Exception { + runTest("compiler/testData/codegen/boxInline/signature/typeParametersSubstitution2.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/simple") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Simple extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInSimple() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/simple"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("captureAndArgumentIncompatibleTypes.kt") + public void testCaptureAndArgumentIncompatibleTypes() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/captureAndArgumentIncompatibleTypes.kt"); + } + + @TestMetadata("classObject.kt") + public void testClassObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/classObject.kt"); + } + + @TestMetadata("destructuring.kt") + public void testDestructuring() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/destructuring.kt"); + } + + @TestMetadata("destructuringIndexClash.kt") + public void testDestructuringIndexClash() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/destructuringIndexClash.kt"); + } + + @TestMetadata("extension.kt") + public void testExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/extension.kt"); + } + + @TestMetadata("extensionLambda.kt") + public void testExtensionLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/extensionLambda.kt"); + } + + @TestMetadata("funImportedFromObject.kt") + public void testFunImportedFromObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/funImportedFromObject.kt"); + } + + @TestMetadata("inlineCallInInlineLambda.kt") + public void testInlineCallInInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/inlineCallInInlineLambda.kt"); + } + + @TestMetadata("kt17431.kt") + public void testKt17431() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/kt17431.kt"); + } + + @TestMetadata("kt28547.kt") + public void testKt28547() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/kt28547.kt"); + } + + @TestMetadata("kt28547_2.kt") + public void testKt28547_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/kt28547_2.kt"); + } + + @TestMetadata("params.kt") + public void testParams() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/params.kt"); + } + + @TestMetadata("propImportedFromObject.kt") + public void testPropImportedFromObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/propImportedFromObject.kt"); + } + + @TestMetadata("rootConstructor.kt") + public void testRootConstructor() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/rootConstructor.kt"); + } + + @TestMetadata("safeCall.kt") + public void testSafeCall() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/safeCall.kt"); + } + + @TestMetadata("severalClosures.kt") + public void testSeveralClosures() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/severalClosures.kt"); + } + + @TestMetadata("severalUsage.kt") + public void testSeveralUsage() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/severalUsage.kt"); + } + + @TestMetadata("simpleDouble.kt") + public void testSimpleDouble() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/simpleDouble.kt"); + } + + @TestMetadata("simpleEnum.kt") + public void testSimpleEnum() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/simpleEnum.kt"); + } + + @TestMetadata("simpleGenerics.kt") + public void testSimpleGenerics() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/simpleGenerics.kt"); + } + + @TestMetadata("simpleInt.kt") + public void testSimpleInt() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/simpleInt.kt"); + } + + @TestMetadata("simpleLambda.kt") + public void testSimpleLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/simpleLambda.kt"); + } + + @TestMetadata("simpleObject.kt") + public void testSimpleObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/simpleObject.kt"); + } + + @TestMetadata("vararg.kt") + public void testVararg() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/vararg.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/smap") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Smap extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInSmap() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("assertion.kt") + public void testAssertion() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/assertion.kt"); + } + + @TestMetadata("classCycle.kt") + public void testClassCycle() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/classCycle.kt"); + } + + @TestMetadata("classFromDefaultPackage.kt") + public void testClassFromDefaultPackage() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/classFromDefaultPackage.kt"); + } + + @TestMetadata("crossroutines.kt") + public void testCrossroutines() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/crossroutines.kt"); + } + + @TestMetadata("defaultFunction.kt") + public void testDefaultFunction() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultFunction.kt"); + } + + @TestMetadata("defaultFunctionWithInlineCall.kt") + public void testDefaultFunctionWithInlineCall() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultFunctionWithInlineCall.kt"); + } + + @TestMetadata("interleavedFiles.kt") + public void testInterleavedFiles() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/interleavedFiles.kt"); + } + + @TestMetadata("kt23369.kt") + public void testKt23369() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/kt23369.kt"); + } + + @TestMetadata("kt23369_2.kt") + public void testKt23369_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/kt23369_2.kt"); + } + + @TestMetadata("kt23369_3.kt") + public void testKt23369_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/kt23369_3.kt"); + } + + @TestMetadata("kt35006.kt") + public void testKt35006() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/kt35006.kt"); + } + + @TestMetadata("multiFileFacade.kt") + public void testMultiFileFacade() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/multiFileFacade.kt"); + } + + @TestMetadata("oneFile.kt") + public void testOneFile() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/oneFile.kt"); + } + + @TestMetadata("rangeFolding.kt") + public void testRangeFolding() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/rangeFolding.kt"); + } + + @TestMetadata("rangeFoldingInClass.kt") + public void testRangeFoldingInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/rangeFoldingInClass.kt"); + } + + @TestMetadata("smap.kt") + public void testSmap() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/smap.kt"); + } + + @TestMetadata("smapWithNewSyntax.kt") + public void testSmapWithNewSyntax() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/smapWithNewSyntax.kt"); + } + + @TestMetadata("smapWithOldSyntax.kt") + public void testSmapWithOldSyntax() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/smapWithOldSyntax.kt"); + } + + @TestMetadata("compiler/testData/codegen/boxInline/smap/anonymous") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Anonymous extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInAnonymous() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("kt19175.kt") + public void testKt19175() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/kt19175.kt"); + } + + @TestMetadata("lambda.kt") + public void testLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/lambda.kt"); + } + + @TestMetadata("lambdaOnCallSite.kt") + public void testLambdaOnCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/lambdaOnCallSite.kt"); + } + + @TestMetadata("lambdaOnInlineCallSite.kt") + public void testLambdaOnInlineCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/lambdaOnInlineCallSite.kt"); + } + + @TestMetadata("object.kt") + public void testObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/object.kt"); + } + + @TestMetadata("objectOnCallSite.kt") + public void testObjectOnCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/objectOnCallSite.kt"); + } + + @TestMetadata("objectOnInlineCallSite.kt") + public void testObjectOnInlineCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/objectOnInlineCallSite.kt"); + } + + @TestMetadata("objectOnInlineCallSite2.kt") + public void testObjectOnInlineCallSite2() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/objectOnInlineCallSite2.kt"); + } + + @TestMetadata("objectOnInlineCallSiteWithCapture.kt") + public void testObjectOnInlineCallSiteWithCapture() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/objectOnInlineCallSiteWithCapture.kt"); + } + + @TestMetadata("severalMappingsForDefaultFile.kt") + public void testSeveralMappingsForDefaultFile() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/severalMappingsForDefaultFile.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/smap/defaultLambda") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DefaultLambda extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInDefaultLambda() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("defaultLambdaInAnonymous.kt") + public void testDefaultLambdaInAnonymous() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/defaultLambdaInAnonymous.kt"); + } + + @TestMetadata("inlinInDefault.kt") + public void testInlinInDefault() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/inlinInDefault.kt"); + } + + @TestMetadata("inlinInDefault2.kt") + public void testInlinInDefault2() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/inlinInDefault2.kt"); + } + + @TestMetadata("inlineAnonymousInDefault.kt") + public void testInlineAnonymousInDefault() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/inlineAnonymousInDefault.kt"); + } + + @TestMetadata("inlineAnonymousInDefault2.kt") + public void testInlineAnonymousInDefault2() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/inlineAnonymousInDefault2.kt"); + } + + @TestMetadata("kt21827.kt") + public void testKt21827() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/kt21827.kt"); + } + + @TestMetadata("nested.kt") + public void testNested() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/nested.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/simple.kt"); + } + + @TestMetadata("simple2.kt") + public void testSimple2() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/simple2.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/smap/inlineOnly") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineOnly extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInInlineOnly() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/inlineOnly"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("noSmap.kt") + public void testNoSmap() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/inlineOnly/noSmap.kt"); + } + + @TestMetadata("noSmapWithProperty.kt") + public void testNoSmapWithProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/inlineOnly/noSmapWithProperty.kt"); + } + + @TestMetadata("reified.kt") + public void testReified() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/inlineOnly/reified.kt"); + } + + @TestMetadata("reifiedProperty.kt") + public void testReifiedProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/inlineOnly/reifiedProperty.kt"); + } + + @TestMetadata("stdlibInlineOnly.kt") + public void testStdlibInlineOnly() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/inlineOnly/stdlibInlineOnly.kt"); + } + + @TestMetadata("stdlibInlineOnlyOneLine.kt") + public void testStdlibInlineOnlyOneLine() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/inlineOnly/stdlibInlineOnlyOneLine.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/smap/newsmap") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Newsmap extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInNewsmap() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/newsmap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("differentMapping.kt") + public void testDifferentMapping() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/newsmap/differentMapping.kt"); + } + + @TestMetadata("mappingInInlineFunLambda.kt") + public void testMappingInInlineFunLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/newsmap/mappingInInlineFunLambda.kt"); + } + + @TestMetadata("mappingInSubInlineLambda.kt") + public void testMappingInSubInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/newsmap/mappingInSubInlineLambda.kt"); + } + + @TestMetadata("mappingInSubInlineLambdaSameFileInline.kt") + public void testMappingInSubInlineLambdaSameFileInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/newsmap/mappingInSubInlineLambdaSameFileInline.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/smap/resolve") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Resolve extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInResolve() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/resolve"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("inlineComponent.kt") + public void testInlineComponent() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/resolve/inlineComponent.kt"); + } + + @TestMetadata("inlineIterator.kt") + public void testInlineIterator() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/resolve/inlineIterator.kt"); + } + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/special") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Special extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInSpecial() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/special"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("identityCheck.kt") + public void testIdentityCheck() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/identityCheck.kt"); + } + + @TestMetadata("ifBranches.kt") + public void testIfBranches() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/ifBranches.kt"); + } + + @TestMetadata("iinc.kt") + public void testIinc() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/iinc.kt"); + } + + @TestMetadata("inlineChain.kt") + public void testInlineChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/inlineChain.kt"); + } + + @TestMetadata("loopInStoreLoadChains.kt") + public void testLoopInStoreLoadChains() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/loopInStoreLoadChains.kt"); + } + + @TestMetadata("loopInStoreLoadChains2.kt") + public void testLoopInStoreLoadChains2() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/loopInStoreLoadChains2.kt"); + } + + @TestMetadata("plusAssign.kt") + public void testPlusAssign() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/plusAssign.kt"); + } + + @TestMetadata("stackHeightBug.kt") + public void testStackHeightBug() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/stackHeightBug.kt"); + } + + @TestMetadata("unusedInlineLambda.kt") + public void testUnusedInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/unusedInlineLambda.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/stackOnReturn") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class StackOnReturn extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInStackOnReturn() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/stackOnReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("elvis.kt") + public void testElvis() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/elvis.kt"); + } + + @TestMetadata("ifThenElse.kt") + public void testIfThenElse() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/ifThenElse.kt"); + } + + @TestMetadata("kt11499.kt") + public void testKt11499() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/kt11499.kt"); + } + + @TestMetadata("kt17591.kt") + public void testKt17591() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/kt17591.kt"); + } + + @TestMetadata("kt17591a.kt") + public void testKt17591a() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/kt17591a.kt"); + } + + @TestMetadata("kt17591b.kt") + public void testKt17591b() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/kt17591b.kt"); + } + + @TestMetadata("mixedTypesOnStack1.kt") + public void testMixedTypesOnStack1() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/mixedTypesOnStack1.kt"); + } + + @TestMetadata("mixedTypesOnStack2.kt") + public void testMixedTypesOnStack2() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/mixedTypesOnStack2.kt"); + } + + @TestMetadata("mixedTypesOnStack3.kt") + public void testMixedTypesOnStack3() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/mixedTypesOnStack3.kt"); + } + + @TestMetadata("nonLocalReturn1.kt") + public void testNonLocalReturn1() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/nonLocalReturn1.kt"); + } + + @TestMetadata("nonLocalReturn2.kt") + public void testNonLocalReturn2() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/nonLocalReturn2.kt"); + } + + @TestMetadata("nonLocalReturn3.kt") + public void testNonLocalReturn3() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/nonLocalReturn3.kt"); + } + + @TestMetadata("poppedLocalReturn.kt") + public void testPoppedLocalReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/poppedLocalReturn.kt"); + } + + @TestMetadata("poppedLocalReturn2.kt") + public void testPoppedLocalReturn2() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/poppedLocalReturn2.kt"); + } + + @TestMetadata("returnLong.kt") + public void testReturnLong() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/returnLong.kt"); + } + + @TestMetadata("tryFinally.kt") + public void testTryFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/tryFinally.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/suspend") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Suspend extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + private void runTestWithPackageReplacement(String testDataFilePath, String packageName) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(filePath -> doTestWithCoroutinesPackageReplacement(filePath, packageName), TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInSuspend() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("capturedVariables.kt") + public void testCapturedVariables_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/capturedVariables.kt", "kotlin.coroutines"); + } + + @TestMetadata("crossinlineSuspendLambdaInsideCrossinlineSuspendLambda.kt") + public void testCrossinlineSuspendLambdaInsideCrossinlineSuspendLambda_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/crossinlineSuspendLambdaInsideCrossinlineSuspendLambda.kt", "kotlin.coroutines"); + } + + @TestMetadata("delegatedProperties.kt") + public void testDelegatedProperties_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/delegatedProperties.kt", "kotlin.coroutines"); + } + + @TestMetadata("doubleRegenerationWithNonSuspendingLambda.kt") + public void testDoubleRegenerationWithNonSuspendingLambda_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/doubleRegenerationWithNonSuspendingLambda.kt", "kotlin.coroutines"); + } + + @TestMetadata("enclodingMethod.kt") + public void testEnclodingMethod_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/enclodingMethod.kt", "kotlin.coroutines"); + } + + @TestMetadata("fileNameInMetadata.kt") + public void testFileNameInMetadata() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/fileNameInMetadata.kt"); + } + + @TestMetadata("inlineOrdinaryOfCrossinlineSuspend.kt") + public void testInlineOrdinaryOfCrossinlineSuspend_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/inlineOrdinaryOfCrossinlineSuspend.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineOrdinaryOfNoinlineSuspend.kt") + public void testInlineOrdinaryOfNoinlineSuspend_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/inlineOrdinaryOfNoinlineSuspend.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendContinuation.kt") + public void testInlineSuspendContinuation_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/inlineSuspendContinuation.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendInMultifileClass.kt") + public void testInlineSuspendInMultifileClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/inlineSuspendInMultifileClass.kt"); + } + + @TestMetadata("inlineSuspendOfCrossinlineOrdinary.kt") + public void testInlineSuspendOfCrossinlineOrdinary_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/inlineSuspendOfCrossinlineOrdinary.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendOfCrossinlineSuspend.kt") + public void testInlineSuspendOfCrossinlineSuspend_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/inlineSuspendOfCrossinlineSuspend.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendOfNoinlineOrdinary.kt") + public void testInlineSuspendOfNoinlineOrdinary_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/inlineSuspendOfNoinlineOrdinary.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendOfNoinlineSuspend.kt") + public void testInlineSuspendOfNoinlineSuspend_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/inlineSuspendOfNoinlineSuspend.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendOfOrdinary.kt") + public void testInlineSuspendOfOrdinary_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/inlineSuspendOfOrdinary.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendOfSuspend.kt") + public void testInlineSuspendOfSuspend_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/inlineSuspendOfSuspend.kt", "kotlin.coroutines"); + } + + @TestMetadata("jvmName.kt") + public void testJvmName_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/jvmName.kt", "kotlin.coroutines"); + } + + @TestMetadata("kt26658.kt") + public void testKt26658() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/kt26658.kt"); + } + + @TestMetadata("maxStackWithCrossinline.kt") + public void testMaxStackWithCrossinline_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/maxStackWithCrossinline.kt", "kotlin.coroutines"); + } + + @TestMetadata("multipleLocals.kt") + public void testMultipleLocals_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/multipleLocals.kt", "kotlin.coroutines"); + } + + @TestMetadata("multipleSuspensionPoints.kt") + public void testMultipleSuspensionPoints_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/multipleSuspensionPoints.kt", "kotlin.coroutines"); + } + + @TestMetadata("nestedMethodWith2XParameter.kt") + public void testNestedMethodWith2XParameter() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/nestedMethodWith2XParameter.kt"); + } + + @TestMetadata("nonLocalReturn.kt") + public void testNonLocalReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/nonLocalReturn.kt"); + } + + @TestMetadata("nonSuspendCrossinline.kt") + public void testNonSuspendCrossinline_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/nonSuspendCrossinline.kt", "kotlin.coroutines"); + } + + @TestMetadata("returnValue.kt") + public void testReturnValue_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/returnValue.kt", "kotlin.coroutines"); + } + + @TestMetadata("tryCatchReceiver.kt") + public void testTryCatchReceiver_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/tryCatchReceiver.kt", "kotlin.coroutines"); + } + + @TestMetadata("tryCatchStackTransform.kt") + public void testTryCatchStackTransform_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/tryCatchStackTransform.kt", "kotlin.coroutines"); + } + + @TestMetadata("twiceRegeneratedAnonymousObject.kt") + public void testTwiceRegeneratedAnonymousObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/twiceRegeneratedAnonymousObject.kt"); + } + + @TestMetadata("twiceRegeneratedSuspendLambda.kt") + public void testTwiceRegeneratedSuspendLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/twiceRegeneratedSuspendLambda.kt"); + } + + @TestMetadata("compiler/testData/codegen/boxInline/suspend/callableReference") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class CallableReference extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInCallableReference() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("nonTailCall.kt") + public void testNonTailCall() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/callableReference/nonTailCall.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/callableReference/simple.kt"); + } + + @TestMetadata("unitReturn.kt") + public void testUnitReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/callableReference/unitReturn.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/suspend/defaultParameter") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DefaultParameter extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + private void runTestWithPackageReplacement(String testDataFilePath, String packageName) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(filePath -> doTestWithCoroutinesPackageReplacement(filePath, packageName), TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInDefaultParameter() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/defaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("defaultValueCrossinline.kt") + public void testDefaultValueCrossinline_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/defaultParameter/defaultValueCrossinline.kt", "kotlin.coroutines"); + } + + @TestMetadata("defaultValueInClass.kt") + public void testDefaultValueInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/defaultParameter/defaultValueInClass.kt"); + } + + @TestMetadata("defaultValueInlineFromMultiFileFacade.kt") + public void testDefaultValueInlineFromMultiFileFacade_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/defaultParameter/defaultValueInlineFromMultiFileFacade.kt", "kotlin.coroutines"); + } + + @TestMetadata("defaultValueInline.kt") + public void testDefaultValueInline_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/defaultParameter/defaultValueInline.kt", "kotlin.coroutines"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class InlineUsedAsNoinline extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInInlineUsedAsNoinline() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("inlineOnly.kt") + public void testInlineOnly() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline/inlineOnly.kt"); + } + + @TestMetadata("simpleNamed.kt") + public void testSimpleNamed() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline/simpleNamed.kt"); + } + + @TestMetadata("withCapturedInlineLambda.kt") + public void testWithCapturedInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline/withCapturedInlineLambda.kt"); + } + + @TestMetadata("withCapturedInlineLambda2.kt") + public void testWithCapturedInlineLambda2() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline/withCapturedInlineLambda2.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/suspend/receiver") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Receiver extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + private void runTestWithPackageReplacement(String testDataFilePath, String packageName) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(filePath -> doTestWithCoroutinesPackageReplacement(filePath, packageName), TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInReceiver() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/receiver"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("inlineOrdinaryOfCrossinlineSuspend.kt") + public void testInlineOrdinaryOfCrossinlineSuspend_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/receiver/inlineOrdinaryOfCrossinlineSuspend.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineOrdinaryOfNoinlineSuspend.kt") + public void testInlineOrdinaryOfNoinlineSuspend_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/receiver/inlineOrdinaryOfNoinlineSuspend.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendOfCrossinlineOrdinary.kt") + public void testInlineSuspendOfCrossinlineOrdinary_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfCrossinlineOrdinary.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendOfCrossinlineSuspend.kt") + public void testInlineSuspendOfCrossinlineSuspend_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfCrossinlineSuspend.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendOfNoinlineOrdinary.kt") + public void testInlineSuspendOfNoinlineOrdinary_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfNoinlineOrdinary.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendOfNoinlineSuspend.kt") + public void testInlineSuspendOfNoinlineSuspend_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfNoinlineSuspend.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendOfOrdinary.kt") + public void testInlineSuspendOfOrdinary_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfOrdinary.kt", "kotlin.coroutines"); + } + + @TestMetadata("inlineSuspendOfSuspend.kt") + public void testInlineSuspendOfSuspend_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfSuspend.kt", "kotlin.coroutines"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/suspend/stateMachine") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class StateMachine extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + private void runTestWithPackageReplacement(String testDataFilePath, String packageName) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(filePath -> doTestWithCoroutinesPackageReplacement(filePath, packageName), TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInStateMachine() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("crossingCoroutineBoundaries.kt") + public void testCrossingCoroutineBoundaries_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/crossingCoroutineBoundaries.kt", "kotlin.coroutines"); + } + + @TestMetadata("independentInline.kt") + public void testIndependentInline_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/independentInline.kt", "kotlin.coroutines"); + } + + @TestMetadata("innerLambdaInsideLambda.kt") + public void testInnerLambdaInsideLambda_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/innerLambdaInsideLambda.kt", "kotlin.coroutines"); + } + + @TestMetadata("innerLambdaWithoutCrossinline.kt") + public void testInnerLambdaWithoutCrossinline_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/innerLambdaWithoutCrossinline.kt", "kotlin.coroutines"); + } + + @TestMetadata("innerLambda.kt") + public void testInnerLambda_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/innerLambda.kt", "kotlin.coroutines"); + } + + @TestMetadata("innerMadnessCallSite.kt") + public void testInnerMadnessCallSite_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/innerMadnessCallSite.kt", "kotlin.coroutines"); + } + + @TestMetadata("innerMadness.kt") + public void testInnerMadness_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/innerMadness.kt", "kotlin.coroutines"); + } + + @TestMetadata("innerObjectInsideInnerObject.kt") + public void testInnerObjectInsideInnerObject_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/innerObjectInsideInnerObject.kt", "kotlin.coroutines"); + } + + @TestMetadata("innerObjectRetransformation.kt") + public void testInnerObjectRetransformation_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/innerObjectRetransformation.kt", "kotlin.coroutines"); + } + + @TestMetadata("innerObjectSeveralFunctions.kt") + public void testInnerObjectSeveralFunctions_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/innerObjectSeveralFunctions.kt", "kotlin.coroutines"); + } + + @TestMetadata("innerObjectWithoutCapturingCrossinline.kt") + public void testInnerObjectWithoutCapturingCrossinline_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/innerObjectWithoutCapturingCrossinline.kt", "kotlin.coroutines"); + } + + @TestMetadata("innerObject.kt") + public void testInnerObject_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/innerObject.kt", "kotlin.coroutines"); + } + + @TestMetadata("insideObject.kt") + public void testInsideObject_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/insideObject.kt", "kotlin.coroutines"); + } + + @TestMetadata("lambdaTransformation.kt") + public void testLambdaTransformation() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/lambdaTransformation.kt"); + } + + @TestMetadata("normalInline.kt") + public void testNormalInline_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/normalInline.kt", "kotlin.coroutines"); + } + + @TestMetadata("numberOfSuspentions.kt") + public void testNumberOfSuspentions_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/numberOfSuspentions.kt", "kotlin.coroutines"); + } + + @TestMetadata("objectInsideLambdas.kt") + public void testObjectInsideLambdas_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/objectInsideLambdas.kt", "kotlin.coroutines"); + } + + @TestMetadata("oneInlineTwoCaptures.kt") + public void testOneInlineTwoCaptures_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/oneInlineTwoCaptures.kt", "kotlin.coroutines"); + } + + @TestMetadata("passLambda.kt") + public void testPassLambda_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/passLambda.kt", "kotlin.coroutines"); + } + + @TestMetadata("passParameterLambda.kt") + public void testPassParameterLambda_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/passParameterLambda.kt", "kotlin.coroutines"); + } + + @TestMetadata("passParameter.kt") + public void testPassParameter_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/passParameter.kt", "kotlin.coroutines"); + } + + @TestMetadata("unreachableSuspendMarker.kt") + public void testUnreachableSuspendMarker_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/codegen/boxInline/suspend/stateMachine/unreachableSuspendMarker.kt", "kotlin.coroutines"); + } + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/syntheticAccessors") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class SyntheticAccessors extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInSyntheticAccessors() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("constField.kt") + public void testConstField() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/constField.kt"); + } + + @TestMetadata("packagePrivateMembers.kt") + public void testPackagePrivateMembers() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/packagePrivateMembers.kt"); + } + + @TestMetadata("propertyModifiers.kt") + public void testPropertyModifiers() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/propertyModifiers.kt"); + } + + @TestMetadata("protectedMembers.kt") + public void testProtectedMembers() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/protectedMembers.kt"); + } + + @TestMetadata("protectedMembersFromSuper.kt") + public void testProtectedMembersFromSuper() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/protectedMembersFromSuper.kt"); + } + + @TestMetadata("superCall.kt") + public void testSuperCall() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/superCall.kt"); + } + + @TestMetadata("superCallFromMultipleSubclasses.kt") + public void testSuperCallFromMultipleSubclasses() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/superCallFromMultipleSubclasses.kt"); + } + + @TestMetadata("superProperty.kt") + public void testSuperProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/superProperty.kt"); + } + + @TestMetadata("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class WithinInlineLambda extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInWithinInlineLambda() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("directFieldAccess.kt") + public void testDirectFieldAccess() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/directFieldAccess.kt"); + } + + @TestMetadata("directFieldAccessInCrossInline.kt") + public void testDirectFieldAccessInCrossInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/directFieldAccessInCrossInline.kt"); + } + + @TestMetadata("privateCall.kt") + public void testPrivateCall() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/privateCall.kt"); + } + + @TestMetadata("privateInCrossInline.kt") + public void testPrivateInCrossInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/privateInCrossInline.kt"); + } + + @TestMetadata("privateInDefaultStubArgument.kt") + public void testPrivateInDefaultStubArgument() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/privateInDefaultStubArgument.kt"); + } + + @TestMetadata("protectedInCrossinline.kt") + public void testProtectedInCrossinline() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/protectedInCrossinline.kt"); + } + + @TestMetadata("protectedMembersFromSuper.kt") + public void testProtectedMembersFromSuper() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/protectedMembersFromSuper.kt"); + } + + @TestMetadata("superCall.kt") + public void testSuperCall() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/superCall.kt"); + } + + @TestMetadata("superInCrossInline.kt") + public void testSuperInCrossInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/superInCrossInline.kt"); + } + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/trait") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Trait extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInTrait() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("trait.kt") + public void testTrait() throws Exception { + runTest("compiler/testData/codegen/boxInline/trait/trait.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/tryCatchFinally") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TryCatchFinally extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInTryCatchFinally() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("kt5863.kt") + public void testKt5863() throws Exception { + runTest("compiler/testData/codegen/boxInline/tryCatchFinally/kt5863.kt"); + } + + @TestMetadata("tryCatch.kt") + public void testTryCatch() throws Exception { + runTest("compiler/testData/codegen/boxInline/tryCatchFinally/tryCatch.kt"); + } + + @TestMetadata("tryCatch2.kt") + public void testTryCatch2() throws Exception { + runTest("compiler/testData/codegen/boxInline/tryCatchFinally/tryCatch2.kt"); + } + + @TestMetadata("tryCatchFinally.kt") + public void testTryCatchFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/tryCatchFinally/tryCatchFinally.kt"); + } + } + + @TestMetadata("compiler/testData/codegen/boxInline/varargs") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Varargs extends AbstractJvmOldAgainstIrBoxInlineTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTestWithCustomIgnoreDirective(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath, "// IGNORE_BACKEND_MULTI_MODULE: "); + } + + public void testAllFilesPresentInVarargs() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("kt17653.kt") + public void testKt17653() throws Exception { + runTest("compiler/testData/codegen/boxInline/varargs/kt17653.kt"); + } + + @TestMetadata("varargAndDefaultParameters.kt") + public void testVarargAndDefaultParameters() throws Exception { + runTest("compiler/testData/codegen/boxInline/varargs/varargAndDefaultParameters.kt"); + } + + @TestMetadata("varargAndDefaultParameters2.kt") + public void testVarargAndDefaultParameters2() throws Exception { + runTest("compiler/testData/codegen/boxInline/varargs/varargAndDefaultParameters2.kt"); + } + } +} diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/ir/JvmOldAgainstIrBoxTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/ir/JvmOldAgainstIrBoxTestGenerated.java new file mode 100644 index 00000000000..36f3d5d4dae --- /dev/null +++ b/compiler/tests/org/jetbrains/kotlin/codegen/ir/JvmOldAgainstIrBoxTestGenerated.java @@ -0,0 +1,639 @@ +/* + * Copyright 2010-2020 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.codegen.ir; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; +import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.TargetBackend; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.runner.RunWith; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("compiler/testData/compileKotlinAgainstKotlin") +@TestDataPath("$PROJECT_ROOT") +@RunWith(JUnit3RunnerWithInners.class) +public class JvmOldAgainstIrBoxTestGenerated extends AbstractJvmOldAgainstIrBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath); + } + + private void runTestWithPackageReplacement(String testDataFilePath, String packageName) throws Exception { + KotlinTestUtils.runTest(filePath -> doTestWithCoroutinesPackageReplacement(filePath, packageName), TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath); + } + + public void testAllFilesPresentInCompileKotlinAgainstKotlin() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("annotationInInterface.kt") + public void testAnnotationInInterface() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/annotationInInterface.kt"); + } + + @TestMetadata("annotationOnTypeUseInTypeAlias.kt") + public void testAnnotationOnTypeUseInTypeAlias() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/annotationOnTypeUseInTypeAlias.kt"); + } + + @TestMetadata("annotationsOnTypeAliases.kt") + public void testAnnotationsOnTypeAliases() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/annotationsOnTypeAliases.kt"); + } + + @TestMetadata("callDeserializedPropertyOnInlineClassType.kt") + public void testCallDeserializedPropertyOnInlineClassType() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/callDeserializedPropertyOnInlineClassType.kt"); + } + + @TestMetadata("callsToMultifileClassFromOtherPackage.kt") + public void testCallsToMultifileClassFromOtherPackage() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/callsToMultifileClassFromOtherPackage.kt"); + } + + @TestMetadata("classInObject.kt") + public void testClassInObject() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/classInObject.kt"); + } + + @TestMetadata("companionObjectInEnum.kt") + public void testCompanionObjectInEnum() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/companionObjectInEnum.kt"); + } + + @TestMetadata("companionObjectMember.kt") + public void testCompanionObjectMember() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/companionObjectMember.kt"); + } + + @TestMetadata("constPropertyReferenceFromMultifileClass.kt") + public void testConstPropertyReferenceFromMultifileClass() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/constPropertyReferenceFromMultifileClass.kt"); + } + + @TestMetadata("constructorVararg.kt") + public void testConstructorVararg() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/constructorVararg.kt"); + } + + @TestMetadata("constructorWithInlineClassParametersInBinaryDependencies.kt") + public void testConstructorWithInlineClassParametersInBinaryDependencies() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/constructorWithInlineClassParametersInBinaryDependencies.kt"); + } + + @TestMetadata("copySamOnInline.kt") + public void testCopySamOnInline() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/copySamOnInline.kt"); + } + + @TestMetadata("copySamOnInline2.kt") + public void testCopySamOnInline2() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/copySamOnInline2.kt"); + } + + @TestMetadata("coroutinesBinary.kt") + public void testCoroutinesBinary_1_3() throws Exception { + runTestWithPackageReplacement("compiler/testData/compileKotlinAgainstKotlin/coroutinesBinary.kt", "kotlin.coroutines"); + } + + @TestMetadata("defaultConstructor.kt") + public void testDefaultConstructor() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/defaultConstructor.kt"); + } + + @TestMetadata("defaultLambdaRegeneration.kt") + public void testDefaultLambdaRegeneration() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/defaultLambdaRegeneration.kt"); + } + + @TestMetadata("defaultLambdaRegeneration2.kt") + public void testDefaultLambdaRegeneration2() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/defaultLambdaRegeneration2.kt"); + } + + @TestMetadata("delegatedDefault.kt") + public void testDelegatedDefault() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/delegatedDefault.kt"); + } + + @TestMetadata("delegationAndAnnotations.kt") + public void testDelegationAndAnnotations() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/delegationAndAnnotations.kt"); + } + + @TestMetadata("doublyNestedClass.kt") + public void testDoublyNestedClass() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/doublyNestedClass.kt"); + } + + @TestMetadata("enum.kt") + public void testEnum() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/enum.kt"); + } + + @TestMetadata("expectClassActualTypeAlias.kt") + public void testExpectClassActualTypeAlias() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/expectClassActualTypeAlias.kt"); + } + + @TestMetadata("inlineClassFromBinaryDependencies.kt") + public void testInlineClassFromBinaryDependencies() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/inlineClassFromBinaryDependencies.kt"); + } + + @TestMetadata("inlineClassInlineProperty.kt") + public void testInlineClassInlineProperty() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/inlineClassInlineProperty.kt"); + } + + @TestMetadata("inlinedConstants.kt") + public void testInlinedConstants() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/inlinedConstants.kt"); + } + + @TestMetadata("innerClassConstructor.kt") + public void testInnerClassConstructor() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/innerClassConstructor.kt"); + } + + @TestMetadata("interfaceDelegationAndBridgesProcessing.kt") + public void testInterfaceDelegationAndBridgesProcessing() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/interfaceDelegationAndBridgesProcessing.kt"); + } + + @TestMetadata("internalSetterOverridden.kt") + public void testInternalSetterOverridden() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/internalSetterOverridden.kt"); + } + + @TestMetadata("internalWithOtherModuleName.kt") + public void testInternalWithOtherModuleName() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/internalWithOtherModuleName.kt"); + } + + @TestMetadata("jvmField.kt") + public void testJvmField() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvmField.kt"); + } + + @TestMetadata("jvmFieldInAnnotationCompanion.kt") + public void testJvmFieldInAnnotationCompanion() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvmFieldInAnnotationCompanion.kt"); + } + + @TestMetadata("jvmFieldInConstructor.kt") + public void testJvmFieldInConstructor() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvmFieldInConstructor.kt"); + } + + @TestMetadata("jvmFieldInInterfaceCompanion.kt") + public void testJvmFieldInInterfaceCompanion() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvmFieldInInterfaceCompanion.kt"); + } + + @TestMetadata("jvmNames.kt") + public void testJvmNames() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvmNames.kt"); + } + + @TestMetadata("jvmPackageName.kt") + public void testJvmPackageName() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvmPackageName.kt"); + } + + @TestMetadata("jvmPackageNameInRootPackage.kt") + public void testJvmPackageNameInRootPackage() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvmPackageNameInRootPackage.kt"); + } + + @TestMetadata("jvmPackageNameMultifileClass.kt") + public void testJvmPackageNameMultifileClass() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvmPackageNameMultifileClass.kt"); + } + + @TestMetadata("jvmPackageNameWithJvmName.kt") + public void testJvmPackageNameWithJvmName() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvmPackageNameWithJvmName.kt"); + } + + @TestMetadata("jvmStaticInObject.kt") + public void testJvmStaticInObject() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvmStaticInObject.kt"); + } + + @TestMetadata("kotlinPropertyAsAnnotationParameter.kt") + public void testKotlinPropertyAsAnnotationParameter() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/kotlinPropertyAsAnnotationParameter.kt"); + } + + @TestMetadata("kt14012.kt") + public void testKt14012() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/kt14012.kt"); + } + + @TestMetadata("kt14012_multi.kt") + public void testKt14012_multi() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/kt14012_multi.kt"); + } + + @TestMetadata("kt21775.kt") + public void testKt21775() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/kt21775.kt"); + } + + @TestMetadata("metadataForMembersInLocalClassInInitializer.kt") + public void testMetadataForMembersInLocalClassInInitializer() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/metadataForMembersInLocalClassInInitializer.kt"); + } + + @TestMetadata("multifileClassInlineFunctionAccessingProperty.kt") + public void testMultifileClassInlineFunctionAccessingProperty() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/multifileClassInlineFunctionAccessingProperty.kt"); + } + + @TestMetadata("multifileClassWithTypealias.kt") + public void testMultifileClassWithTypealias() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/multifileClassWithTypealias.kt"); + } + + @TestMetadata("nestedClass.kt") + public void testNestedClass() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/nestedClass.kt"); + } + + @TestMetadata("nestedClassInAnnotationArgument.kt") + public void testNestedClassInAnnotationArgument() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/nestedClassInAnnotationArgument.kt"); + } + + @TestMetadata("nestedEnum.kt") + public void testNestedEnum() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/nestedEnum.kt"); + } + + @TestMetadata("nestedFunctionTypeAliasExpansion.kt") + public void testNestedFunctionTypeAliasExpansion() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/nestedFunctionTypeAliasExpansion.kt"); + } + + @TestMetadata("nestedObject.kt") + public void testNestedObject() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/nestedObject.kt"); + } + + @TestMetadata("nestedTypeAliasExpansion.kt") + public void testNestedTypeAliasExpansion() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/nestedTypeAliasExpansion.kt"); + } + + @TestMetadata("optionalAnnotation.kt") + public void testOptionalAnnotation() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/optionalAnnotation.kt"); + } + + @TestMetadata("platformTypes.kt") + public void testPlatformTypes() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/platformTypes.kt"); + } + + @TestMetadata("privateCompanionObjectValInDifferentModule.kt") + public void testPrivateCompanionObjectValInDifferentModule() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/privateCompanionObjectValInDifferentModule.kt"); + } + + @TestMetadata("privateTopLevelValInDifferentModule.kt") + public void testPrivateTopLevelValInDifferentModule() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/privateTopLevelValInDifferentModule.kt"); + } + + @TestMetadata("propertyReference.kt") + public void testPropertyReference() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/propertyReference.kt"); + } + + @TestMetadata("recursiveGeneric.kt") + public void testRecursiveGeneric() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/recursiveGeneric.kt"); + } + + @TestMetadata("reflectTopLevelFunctionOtherFile.kt") + public void testReflectTopLevelFunctionOtherFile() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/reflectTopLevelFunctionOtherFile.kt"); + } + + @TestMetadata("sealedClass.kt") + public void testSealedClass() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/sealedClass.kt"); + } + + @TestMetadata("secondaryConstructors.kt") + public void testSecondaryConstructors() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/secondaryConstructors.kt"); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/simple.kt"); + } + + @TestMetadata("simpleValAnonymousObject.kt") + public void testSimpleValAnonymousObject() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/simpleValAnonymousObject.kt"); + } + + @TestMetadata("specialBridgesInDependencies.kt") + public void testSpecialBridgesInDependencies() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/specialBridgesInDependencies.kt"); + } + + @TestMetadata("starImportEnum.kt") + public void testStarImportEnum() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/starImportEnum.kt"); + } + + @TestMetadata("targetedJvmName.kt") + public void testTargetedJvmName() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/targetedJvmName.kt"); + } + + @TestMetadata("typeAliasesKt13181.kt") + public void testTypeAliasesKt13181() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/typeAliasesKt13181.kt"); + } + + @TestMetadata("unsignedTypesInAnnotations.kt") + public void testUnsignedTypesInAnnotations() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/unsignedTypesInAnnotations.kt"); + } + + @TestMetadata("useDeserializedFunInterface.kt") + public void testUseDeserializedFunInterface() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/useDeserializedFunInterface.kt"); + } + + @TestMetadata("compiler/testData/compileKotlinAgainstKotlin/jvm8") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Jvm8 extends AbstractJvmOldAgainstIrBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath); + } + + public void testAllFilesPresentInJvm8() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Defaults extends AbstractJvmOldAgainstIrBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath); + } + + public void testAllFilesPresentInDefaults() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("superCall.kt") + public void testSuperCall() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/superCall.kt"); + } + + @TestMetadata("superCallFromInterface.kt") + public void testSuperCallFromInterface() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/superCallFromInterface.kt"); + } + + @TestMetadata("superCallFromInterface2.kt") + public void testSuperCallFromInterface2() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/superCallFromInterface2.kt"); + } + + @TestMetadata("superPropAccess.kt") + public void testSuperPropAccess() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/superPropAccess.kt"); + } + + @TestMetadata("superPropAccessFromInterface.kt") + public void testSuperPropAccessFromInterface() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/superPropAccessFromInterface.kt"); + } + + @TestMetadata("superPropAccessFromInterface2.kt") + public void testSuperPropAccessFromInterface2() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/superPropAccessFromInterface2.kt"); + } + + @TestMetadata("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AllCompatibility extends AbstractJvmOldAgainstIrBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath); + } + + public void testAllFilesPresentInAllCompatibility() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("callStackTrace.kt") + public void testCallStackTrace() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/callStackTrace.kt"); + } + + @TestMetadata("superCall.kt") + public void testSuperCall() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superCall.kt"); + } + + @TestMetadata("superCallFromInterface.kt") + public void testSuperCallFromInterface() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superCallFromInterface.kt"); + } + + @TestMetadata("superCallFromInterface2.kt") + public void testSuperCallFromInterface2() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superCallFromInterface2.kt"); + } + + @TestMetadata("superPropAccess.kt") + public void testSuperPropAccess() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superPropAccess.kt"); + } + + @TestMetadata("superPropAccessFromInterface.kt") + public void testSuperPropAccessFromInterface() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superPropAccessFromInterface.kt"); + } + + @TestMetadata("superPropAccessFromInterface2.kt") + public void testSuperPropAccessFromInterface2() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/superPropAccessFromInterface2.kt"); + } + + @TestMetadata("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/delegationBy") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DelegationBy extends AbstractJvmOldAgainstIrBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath); + } + + public void testAllFilesPresentInDelegationBy() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/delegationBy/simple.kt"); + } + + @TestMetadata("simpleProperty.kt") + public void testSimpleProperty() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/allCompatibility/delegationBy/simpleProperty.kt"); + } + } + } + + @TestMetadata("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Interop extends AbstractJvmOldAgainstIrBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath); + } + + public void testAllFilesPresentInInterop() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("likeMemberClash.kt") + public void testLikeMemberClash() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop/likeMemberClash.kt"); + } + + @TestMetadata("likeSpecialization.kt") + public void testLikeSpecialization() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop/likeSpecialization.kt"); + } + + @TestMetadata("newAndOldSchemes.kt") + public void testNewAndOldSchemes() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop/newAndOldSchemes.kt"); + } + + @TestMetadata("newAndOldSchemes2.kt") + public void testNewAndOldSchemes2() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop/newAndOldSchemes2.kt"); + } + + @TestMetadata("newAndOldSchemes2Compatibility.kt") + public void testNewAndOldSchemes2Compatibility() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop/newAndOldSchemes2Compatibility.kt"); + } + + @TestMetadata("newSchemeWithJvmDefault.kt") + public void testNewSchemeWithJvmDefault() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/defaults/interop/newSchemeWithJvmDefault.kt"); + } + } + } + + @TestMetadata("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Jvm8against6 extends AbstractJvmOldAgainstIrBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath); + } + + public void testAllFilesPresentInJvm8against6() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("jdk8Against6.kt") + public void testJdk8Against6() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/jdk8Against6.kt"); + } + + @TestMetadata("simpleCall.kt") + public void testSimpleCall() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/simpleCall.kt"); + } + + @TestMetadata("simpleCallWithBigHierarchy.kt") + public void testSimpleCallWithBigHierarchy() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/simpleCallWithBigHierarchy.kt"); + } + + @TestMetadata("simpleCallWithHierarchy.kt") + public void testSimpleCallWithHierarchy() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/simpleCallWithHierarchy.kt"); + } + + @TestMetadata("simpleProp.kt") + public void testSimpleProp() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/simpleProp.kt"); + } + + @TestMetadata("simplePropWithHierarchy.kt") + public void testSimplePropWithHierarchy() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/simplePropWithHierarchy.kt"); + } + + @TestMetadata("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/delegation") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Delegation extends AbstractJvmOldAgainstIrBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath); + } + + public void testAllFilesPresentInDelegation() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/delegation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("diamond.kt") + public void testDiamond() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/delegation/diamond.kt"); + } + + @TestMetadata("diamond2.kt") + public void testDiamond2() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/delegation/diamond2.kt"); + } + + @TestMetadata("diamond3.kt") + public void testDiamond3() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/jvm8/jvm8against6/delegation/diamond3.kt"); + } + } + } + } + + @TestMetadata("compiler/testData/compileKotlinAgainstKotlin/typeAnnotations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeAnnotations extends AbstractJvmOldAgainstIrBoxTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, testDataFilePath); + } + + public void testAllFilesPresentInTypeAnnotations() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/compileKotlinAgainstKotlin/typeAnnotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, true); + } + + @TestMetadata("implicitReturn.kt") + public void testImplicitReturn() throws Exception { + runTest("compiler/testData/compileKotlinAgainstKotlin/typeAnnotations/implicitReturn.kt"); + } + } +} diff --git a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt index 0d067a2f09a..eaf7ac20bc9 100644 --- a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt +++ b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt @@ -442,6 +442,16 @@ fun main(args: Array) { testClass { model("compileKotlinAgainstKotlin", targetBackend = TargetBackend.JVM_IR) } + testClass { + model("compileKotlinAgainstKotlin", targetBackend = TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD) + } + testClass { + model( + "compileKotlinAgainstKotlin", + targetBackend = TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, + skipTestsForExperimentalCoroutines = true + ) + } testClass { model("codegen/bytecodeListing", targetBackend = TargetBackend.JVM_IR) @@ -537,6 +547,16 @@ fun main(args: Array) { testClass { model("codegen/boxInline", targetBackend = TargetBackend.JVM_IR) } + testClass { + model("codegen/boxInline", targetBackend = TargetBackend.JVM_MULTI_MODULE_IR_AGAINST_OLD) + } + testClass { + model( + "codegen/boxInline", + targetBackend = TargetBackend.JVM_MULTI_MODULE_OLD_AGAINST_IR, + skipTestsForExperimentalCoroutines = true + ) + } } testGroup("compiler/fir/raw-fir/psi2fir/tests", "compiler/fir/raw-fir/psi2fir/testData") {