From 9b3237fff9c9918a175dc4f2cb858451beb9ec9c Mon Sep 17 00:00:00 2001 From: Svyatoslav Kuzmich Date: Mon, 12 Jun 2023 11:23:31 +0200 Subject: [PATCH] [Wasm] Initial K2 support in new test infrastructure (KT-57230) - Implement FirWasmSessionFactory - Use new compiler test infra for Wasm K1 and K2 - Delete old Wasm compiler test infra --- build.gradle.kts | 1 - .../kotlin/fir/checkers/CheckersContainers.kt | 4 + .../fir/session/FirWasmSessionFactory.kt | 109 + .../jetbrains/kotlin/test/TestSetupUtils.kt | 3 + .../handlers/BinaryArtifactHandlers.kt | 11 + .../handlers/IrInterpreterDumpHandler.kt | 8 + .../kotlin/test/backend/ir/IrBackendInput.kt | 17 +- .../test/builders/CompilerTestDslHelpers.kt | 14 + .../WasmEnvironmentConfigurationDirectives.kt | 33 + .../classic/ClassicFrontend2IrConverter.kt | 48 + .../frontend/classic/ClassicFrontendFacade.kt | 4 +- .../fir/Fir2IrWasmResultsConverter.kt | 228 + .../test/frontend/fir/FirFrontendFacade.kt | 34 + .../frontend/fir/TestFirWasmSessionFactory.kt | 88 + .../kotlin/test/model/ResultingArtifacts.kt | 9 + .../kotlin/test/model/TestArtifactKinds.kt | 2 + .../test/services/configuration/Helpers.kt | 4 +- .../WasmEnvironmentConfigurator.kt | 106 +- wasm/wasm.tests/build.gradle.kts | 17 +- .../generators/tests/GenerateWasmTests.kt | 101 +- .../kotlin/wasm/test/AbstractFirWasmTest.kt | 92 + .../kotlin/wasm/test/AbstractK1WasmTest.kt | 55 + .../AbstractWasmBlackBoxCodegenTestBase.kt | 112 + .../kotlin/wasm/test/BasicWasmBoxTest.kt | 416 - .../wasm/test/WasmAdditionalSourceProvider.kt | 47 + .../wasm/test/WasmFailingTestSuppressor.kt | 21 + .../abstractClassesForGeneratedWasmTests.kt | 34 - .../converters/FirWasmKlibBackendFacade.kt | 123 + .../wasm/test/converters/WasmBackendFacade.kt | 139 + .../AbstractWasmArtifactsCollector.kt | 19 + .../wasm/test/handlers/WasmBoxRunner.kt | 255 + ...FirWasmCodegenBoxInlineTestGenerated.java} | 1493 +- ...va => FirWasmCodegenBoxTestGenerated.java} | 10005 +++-- ...asmCodegenWasmJsInteropTestGenerated.java} | 35 +- .../FirWasmJsTranslatorTestGenerated.java | 474 + .../JsTranslatorUnitWasmTestGenerated.java | 77 - .../K1WasmCodegenBoxInlineTestGenerated.java | 5123 +++ .../test/K1WasmCodegenBoxTestGenerated.java | 37016 ++++++++++++++++ ...WasmCodegenWasmJsInteropTestGenerated.java | 159 + ...a => K1WasmJsTranslatorTestGenerated.java} | 203 +- 40 files changed, 52444 insertions(+), 4295 deletions(-) create mode 100644 compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirWasmSessionFactory.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/WasmEnvironmentConfigurationDirectives.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrWasmResultsConverter.kt create mode 100644 compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/TestFirWasmSessionFactory.kt create mode 100644 wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/AbstractFirWasmTest.kt create mode 100644 wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/AbstractK1WasmTest.kt create mode 100644 wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/AbstractWasmBlackBoxCodegenTestBase.kt delete mode 100644 wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/BasicWasmBoxTest.kt create mode 100644 wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/WasmAdditionalSourceProvider.kt create mode 100644 wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/WasmFailingTestSuppressor.kt delete mode 100644 wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/abstractClassesForGeneratedWasmTests.kt create mode 100644 wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/converters/FirWasmKlibBackendFacade.kt create mode 100644 wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/converters/WasmBackendFacade.kt create mode 100644 wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/handlers/AbstractWasmArtifactsCollector.kt create mode 100644 wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/handlers/WasmBoxRunner.kt rename wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/{IrCodegenBoxInlineWasmTestGenerated.java => FirWasmCodegenBoxInlineTestGenerated.java} (88%) rename wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/{IrCodegenBoxWasmTestGenerated.java => FirWasmCodegenBoxTestGenerated.java} (90%) rename wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/{IrCodegenWasmJsInteropWasmTestGenerated.java => FirWasmCodegenWasmJsInteropTestGenerated.java} (91%) create mode 100644 wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/FirWasmJsTranslatorTestGenerated.java delete mode 100644 wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/JsTranslatorUnitWasmTestGenerated.java create mode 100644 wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/K1WasmCodegenBoxInlineTestGenerated.java create mode 100644 wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/K1WasmCodegenBoxTestGenerated.java create mode 100644 wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/K1WasmCodegenWasmJsInteropTestGenerated.java rename wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/{JsTranslatorWasmTestGenerated.java => K1WasmJsTranslatorTestGenerated.java} (80%) diff --git a/build.gradle.kts b/build.gradle.kts index 29fc5e6c381..8058f06b4a9 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -672,7 +672,6 @@ tasks { register("wasmCompilerTest") { dependsOn(":wasm:wasm.tests:test") - dependsOn(":wasm:wasm.tests:diagnosticsTest") // Windows WABT release requires Visual C++ Redistributable if (!kotlinBuildProperties.isTeamcityBuild || !org.gradle.internal.os.OperatingSystem.current().isWindows) { dependsOn(":wasm:wasm.ir:test") diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/CheckersContainers.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/CheckersContainers.kt index 64d44dc552c..84466e490de 100644 --- a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/CheckersContainers.kt +++ b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/CheckersContainers.kt @@ -41,4 +41,8 @@ fun FirSessionConfigurator.registerJsCheckers() { fun FirSessionConfigurator.registerNativeCheckers() { useCheckers(NativeDeclarationCheckers) useCheckers(NativeExpressionCheckers) +} + +fun FirSessionConfigurator.registerWasmCheckers() { + // TODO: Implement Wasm checkers (KT-56849) } \ No newline at end of file diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirWasmSessionFactory.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirWasmSessionFactory.kt new file mode 100644 index 00000000000..04205302b91 --- /dev/null +++ b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/FirWasmSessionFactory.kt @@ -0,0 +1,109 @@ +/* + * 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.fir.session + +import org.jetbrains.kotlin.config.LanguageVersionSettings +import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl +import org.jetbrains.kotlin.fir.FirModuleData +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.FirVisibilityChecker +import org.jetbrains.kotlin.fir.SessionConfiguration +import org.jetbrains.kotlin.fir.analysis.FirEmptyOverridesBackwardCompatibilityHelper +import org.jetbrains.kotlin.fir.analysis.FirOverridesBackwardCompatibilityHelper +import org.jetbrains.kotlin.fir.checkers.registerWasmCheckers +import org.jetbrains.kotlin.fir.deserialization.ModuleDataProvider +import org.jetbrains.kotlin.fir.deserialization.SingleModuleDataProvider +import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar +import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider +import org.jetbrains.kotlin.fir.resolve.calls.ConeCallConflictResolverFactory +import org.jetbrains.kotlin.fir.resolve.providers.impl.FirBuiltinSyntheticFunctionInterfaceProvider +import org.jetbrains.kotlin.fir.resolve.providers.impl.FirExtensionSyntheticFunctionInterfaceProvider +import org.jetbrains.kotlin.fir.scopes.FirKotlinScopeProvider +import org.jetbrains.kotlin.fir.scopes.FirPlatformClassMapper +import org.jetbrains.kotlin.incremental.components.LookupTracker +import org.jetbrains.kotlin.library.KotlinLibrary +import org.jetbrains.kotlin.name.Name + +object FirWasmSessionFactory : FirAbstractSessionFactory() { + fun createModuleBasedSession( + moduleData: FirModuleData, + sessionProvider: FirProjectSessionProvider, + extensionRegistrars: List, + languageVersionSettings: LanguageVersionSettings = LanguageVersionSettingsImpl.DEFAULT, + lookupTracker: LookupTracker?, + icData: KlibIcData? = null, + registerExtraComponents: ((FirSession) -> Unit) = {}, + init: FirSessionConfigurator.() -> Unit + ): FirSession { + return createModuleBasedSession( + moduleData, + sessionProvider, + extensionRegistrars, + languageVersionSettings, + lookupTracker, + null, + init, + registerExtraComponents = { session -> + session.registerWasmSpecificComponents() + registerExtraComponents(session) + }, + registerExtraCheckers = { it.registerWasmCheckers() }, + createKotlinScopeProvider = { FirKotlinScopeProvider { _, declaredMemberScope, _, _, _ -> declaredMemberScope } }, + createProviders = { session, kotlinScopeProvider, symbolProvider, generatedSymbolsProvider, syntheticFunctionInterfaceProvider, dependencies -> + listOfNotNull( + symbolProvider, + generatedSymbolsProvider, + icData?.let { + KlibIcCacheBasedSymbolProvider( + session, + SingleModuleDataProvider(moduleData), + kotlinScopeProvider, + it, + ) + }, + syntheticFunctionInterfaceProvider, + *dependencies.toTypedArray(), + ) + } + ) + } + + fun createLibrarySession( + mainModuleName: Name, + resolvedLibraries: List, + sessionProvider: FirProjectSessionProvider, + moduleDataProvider: ModuleDataProvider, + extensionRegistrars: List, + languageVersionSettings: LanguageVersionSettings = LanguageVersionSettingsImpl.DEFAULT, + registerExtraComponents: ((FirSession) -> Unit), + ): FirSession = createLibrarySession( + mainModuleName, + sessionProvider, + moduleDataProvider, + languageVersionSettings, + extensionRegistrars, + registerExtraComponents = { + it.registerWasmSpecificComponents() + registerExtraComponents(it) + }, + createKotlinScopeProvider = { FirKotlinScopeProvider { _, declaredMemberScope, _, _, _ -> declaredMemberScope } }, + createProviders = { session, builtinsModuleData, kotlinScopeProvider -> + listOfNotNull( + KlibBasedSymbolProvider(session, moduleDataProvider, kotlinScopeProvider, resolvedLibraries), + FirBuiltinSyntheticFunctionInterfaceProvider(session, builtinsModuleData, kotlinScopeProvider), + FirExtensionSyntheticFunctionInterfaceProvider.createIfNeeded(session, builtinsModuleData, kotlinScopeProvider), + ) + } + ) + + @OptIn(SessionConfiguration::class) + fun FirSession.registerWasmSpecificComponents() { + register(FirVisibilityChecker::class, FirVisibilityChecker.Default) + register(ConeCallConflictResolverFactory::class, DefaultCallConflictResolverFactory) + register(FirPlatformClassMapper::class, FirPlatformClassMapper.Default) + register(FirOverridesBackwardCompatibilityHelper::class, FirEmptyOverridesBackwardCompatibilityHelper) + } +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/TestSetupUtils.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/TestSetupUtils.kt index d0c7e9d1b79..3f0b4b4eb4b 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/TestSetupUtils.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/TestSetupUtils.kt @@ -10,11 +10,13 @@ import org.jetbrains.kotlin.js.resolve.JsPlatformAnalyzerServices import org.jetbrains.kotlin.platform.TargetPlatform import org.jetbrains.kotlin.platform.isCommon import org.jetbrains.kotlin.platform.isJs +import org.jetbrains.kotlin.platform.isWasm import org.jetbrains.kotlin.platform.jvm.isJvm import org.jetbrains.kotlin.platform.konan.isNative import org.jetbrains.kotlin.resolve.PlatformDependentAnalyzerServices import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatformAnalyzerServices import org.jetbrains.kotlin.resolve.konan.platform.NativePlatformAnalyzerServices +import org.jetbrains.kotlin.wasm.resolve.WasmPlatformAnalyzerServices import java.io.File /** @@ -39,6 +41,7 @@ fun TargetPlatform.getAnalyzerServices(): PlatformDependentAnalyzerServices { isJs() -> JsPlatformAnalyzerServices isNative() -> NativePlatformAnalyzerServices isCommon() -> CommonPlatformAnalyzerServices + isWasm() -> WasmPlatformAnalyzerServices else -> error("Unknown target platform: $this") } } \ No newline at end of file diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/BinaryArtifactHandlers.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/BinaryArtifactHandlers.kt index 66277ecafcc..08c5bb945fc 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/BinaryArtifactHandlers.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/BinaryArtifactHandlers.kt @@ -52,3 +52,14 @@ abstract class NativeBinaryArtifactHandler( failureDisablesNextSteps, doNotRunIfThereWerePreviousFailures ) + +abstract class WasmBinaryArtifactHandler( + testServices: TestServices, + failureDisablesNextSteps: Boolean = false, + doNotRunIfThereWerePreviousFailures: Boolean = false +) : BinaryArtifactHandler( + testServices, + ArtifactKinds.Wasm, + failureDisablesNextSteps, + doNotRunIfThereWerePreviousFailures +) diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrInterpreterDumpHandler.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrInterpreterDumpHandler.kt index eec128f1347..ccfe562e29a 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrInterpreterDumpHandler.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/handlers/IrInterpreterDumpHandler.kt @@ -97,6 +97,14 @@ class JsIrInterpreterDumpHandler(testServices: TestServices) : IrInterpreterDump override fun processAfterAllModules(someAssertionWasFailed: Boolean) {} } +class WasmIrInterpreterDumpHandler(testServices: TestServices) : IrInterpreterDumpHandler, WasmBinaryArtifactHandler(testServices) { + override fun processModule(module: TestModule, info: BinaryArtifacts.Wasm) { + processModule(module) + } + + override fun processAfterAllModules(someAssertionWasFailed: Boolean) {} +} + class KlibInterpreterDumpHandler(testServices: TestServices) : IrInterpreterDumpHandler, KlibArtifactHandler(testServices) { override fun processModule(module: TestModule, info: BinaryArtifacts.KLib) { if (JsEnvironmentConfigurator.isMainModule(module, testServices)) return diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/IrBackendInput.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/IrBackendInput.kt index ee3b0bd9d22..8640b825d67 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/IrBackendInput.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/backend/ir/IrBackendInput.kt @@ -21,7 +21,7 @@ import org.jetbrains.kotlin.metadata.ProtoBuf import org.jetbrains.kotlin.test.model.BackendKinds import org.jetbrains.kotlin.test.model.ResultingArtifact -// IR backend (JVM, JS, Native) +// IR backend (JVM, JS, Native, Wasm) sealed class IrBackendInput : ResultingArtifact.BackendInput() { override val kind: BackendKinds.IrBackend get() = BackendKinds.IrBackend @@ -84,6 +84,21 @@ sealed class IrBackendInput : ResultingArtifact.BackendInput() { val serializeSingleFile: (KtSourceFile, IrActualizedResult?) -> ProtoBuf.PackageFragment, ) : IrBackendInput() + class WasmBackendInput( + override val irModuleFragment: IrModuleFragment, + override val dependentIrModuleFragments: List, + override val irPluginContext: IrPluginContext, + val sourceFiles: List, + val icData: List, + val expectDescriptorToSymbol: MutableMap, // TODO: abstract from descriptors + override val diagnosticReporter: BaseDiagnosticsCollector, + val hasErrors: Boolean, + override val descriptorMangler: KotlinMangler.DescriptorMangler, + override val irMangler: KotlinMangler.IrMangler, + override val firMangler: FirMangler?, + val serializeSingleFile: (KtSourceFile, IrActualizedResult?) -> ProtoBuf.PackageFragment, + ) : IrBackendInput() + class JvmIrBackendInput( val state: GenerationState, val codegenFactory: JvmIrCodegenFactory, diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/CompilerTestDslHelpers.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/CompilerTestDslHelpers.kt index cdc6329fc5a..e127b2f6674 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/CompilerTestDslHelpers.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/builders/CompilerTestDslHelpers.kt @@ -15,6 +15,7 @@ import org.jetbrains.kotlin.test.builders.CompilerStepsNames.JS_ARTIFACTS_HANDLE import org.jetbrains.kotlin.test.builders.CompilerStepsNames.JVM_ARTIFACTS_HANDLERS_STEP_NAME import org.jetbrains.kotlin.test.builders.CompilerStepsNames.KLIB_ARTIFACTS_HANDLERS_STEP_NAME import org.jetbrains.kotlin.test.builders.CompilerStepsNames.RAW_IR_HANDLERS_STEP_NAME +import org.jetbrains.kotlin.test.builders.CompilerStepsNames.WASM_ARTIFACTS_HANDLERS_STEP_NAME import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontend2ClassicBackendConverter import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontend2IrConverter import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendFacade @@ -38,6 +39,7 @@ object CompilerStepsNames { const val JVM_BACKEND_STEP_NAME = "jvm backend" const val JVM_ARTIFACTS_HANDLERS_STEP_NAME = "jvm artifacts handlers" const val JS_ARTIFACTS_HANDLERS_STEP_NAME = "js artifacts handlers" + const val WASM_ARTIFACTS_HANDLERS_STEP_NAME = "wasm artifacts handlers" const val KLIB_ARTIFACTS_HANDLERS_STEP_NAME = "klib artifacts handlers" } @@ -105,6 +107,12 @@ inline fun TestConfigurationBuilder.jsArtifactsHandlersStep( namedHandlersStep(JS_ARTIFACTS_HANDLERS_STEP_NAME, ArtifactKinds.Js, init) } +inline fun TestConfigurationBuilder.wasmArtifactsHandlersStep( + init: HandlersStepBuilder.() -> Unit = {} +) { + namedHandlersStep(WASM_ARTIFACTS_HANDLERS_STEP_NAME, ArtifactKinds.Wasm, init) +} + inline fun TestConfigurationBuilder.klibArtifactsHandlersStep( init: HandlersStepBuilder.() -> Unit = {} ) { @@ -142,6 +150,12 @@ inline fun TestConfigurationBuilder.configureJsArtifactsHandlersStep( configureNamedHandlersStep(JS_ARTIFACTS_HANDLERS_STEP_NAME, ArtifactKinds.Js, init) } +inline fun TestConfigurationBuilder.configureWasmArtifactsHandlersStep( + init: HandlersStepBuilder.() -> Unit = {} +) { + configureNamedHandlersStep(WASM_ARTIFACTS_HANDLERS_STEP_NAME, ArtifactKinds.Wasm, init) +} + inline fun TestConfigurationBuilder.configureKlibArtifactsHandlersStep( init: HandlersStepBuilder.() -> Unit = {} ) { diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/WasmEnvironmentConfigurationDirectives.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/WasmEnvironmentConfigurationDirectives.kt new file mode 100644 index 00000000000..d563dc285f8 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/directives/WasmEnvironmentConfigurationDirectives.kt @@ -0,0 +1,33 @@ +/* + * 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.test.directives + +import org.jetbrains.kotlin.test.directives.model.DirectiveApplicability +import org.jetbrains.kotlin.test.directives.model.SimpleDirectivesContainer + +object WasmEnvironmentConfigurationDirectives : SimpleDirectivesContainer() { + val RUN_UNIT_TESTS by directive( + description = "Run kotlin.test unit tests (function marked with @Test)", + ) + + // Next directives are used only inside test system and must not be present in test file + + val PATH_TO_TEST_DIR by stringDirective( + description = "Specify the path to directory with test files. " + + "This path is used to copy hierarchy from test file to test dir and use the same hierarchy in output dir.", + applicability = DirectiveApplicability.Global + ) + + val PATH_TO_ROOT_OUTPUT_DIR by stringDirective( + description = "Specify the path to output directory, where all artifacts will be stored", + applicability = DirectiveApplicability.Global + ) + + val TEST_GROUP_OUTPUT_DIR_PREFIX by stringDirective( + description = "Specify the prefix directory for output directory that will contains artifacts", + applicability = DirectiveApplicability.Global + ) +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontend2IrConverter.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontend2IrConverter.kt index c1b8129b915..a609850d809 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontend2IrConverter.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontend2IrConverter.kt @@ -9,6 +9,7 @@ import org.jetbrains.kotlin.KtPsiSourceFile import org.jetbrains.kotlin.backend.jvm.JvmIrCodegenFactory import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys import org.jetbrains.kotlin.cli.js.klib.TopDownAnalyzerFacadeForJSIR +import org.jetbrains.kotlin.cli.js.klib.TopDownAnalyzerFacadeForWasm import org.jetbrains.kotlin.cli.js.klib.generateIrForKlibSerialization import org.jetbrains.kotlin.codegen.ClassBuilderFactories import org.jetbrains.kotlin.codegen.CodegenFactory @@ -33,6 +34,7 @@ import org.jetbrains.kotlin.test.model.FrontendKinds import org.jetbrains.kotlin.test.model.TestModule import org.jetbrains.kotlin.test.services.* import org.jetbrains.kotlin.test.services.configuration.JsEnvironmentConfigurator +import org.jetbrains.kotlin.test.services.configuration.WasmEnvironmentConfigurator class ClassicFrontend2IrConverter( testServices: TestServices @@ -48,6 +50,7 @@ class ClassicFrontend2IrConverter( return when (module.targetBackend) { TargetBackend.JVM_IR -> transformToJvmIr(module, inputArtifact) TargetBackend.JS_IR, TargetBackend.JS_IR_ES6 -> transformToJsIr(module, inputArtifact) + TargetBackend.WASM -> transformToWasmIr(module, inputArtifact) else -> testServices.assertions.fail { "Target backend ${module.targetBackend} not supported for transformation into IR" } } } @@ -125,4 +128,49 @@ class ClassicFrontend2IrConverter( metadataSerializer.serializeScope(file, analysisResult.bindingContext, moduleFragment.descriptor) } } + + private fun transformToWasmIr(module: TestModule, inputArtifact: ClassicFrontendOutputArtifact): IrBackendInput { + val (psiFiles, analysisResult, project, _) = inputArtifact + + val configuration = testServices.compilerConfigurationProvider.getCompilerConfiguration(module) + val verifySignatures = JsEnvironmentConfigurationDirectives.SKIP_MANGLE_VERIFICATION !in module.directives + + val sourceFiles = psiFiles.values.toList() + val icData = configuration.incrementalDataProvider?.getSerializedData(sourceFiles) ?: emptyList() + val expectDescriptorToSymbol = mutableMapOf() + + val (moduleFragment, pluginContext) = generateIrForKlibSerialization( + project, + sourceFiles, + configuration, + analysisResult, + sortDependencies(WasmEnvironmentConfigurator.getAllDependenciesMappingFor(module, testServices)), + icData, + expectDescriptorToSymbol, + IrFactoryImpl, + verifySignatures + ) { + testServices.libraryProvider.getDescriptorByCompiledLibrary(it) + } + + val errorPolicy = configuration.get(JSConfigurationKeys.ERROR_TOLERANCE_POLICY) ?: ErrorTolerancePolicy.DEFAULT + val hasErrors = TopDownAnalyzerFacadeForWasm.checkForErrors(sourceFiles, analysisResult.bindingContext, errorPolicy) + val metadataSerializer = KlibMetadataIncrementalSerializer(configuration, project, hasErrors) + + return IrBackendInput.WasmBackendInput( + moduleFragment, + dependentIrModuleFragments = emptyList(), + pluginContext, + sourceFiles.map(::KtPsiSourceFile), + icData, + expectDescriptorToSymbol = expectDescriptorToSymbol, + diagnosticReporter = DiagnosticReporterFactory.createReporter(), + hasErrors, + descriptorMangler = (pluginContext.symbolTable as SymbolTable).signaturer.mangler, + irMangler = JsManglerIr, + firMangler = null, + ) { file, _ -> + metadataSerializer.serializeScope(file, analysisResult.bindingContext, moduleFragment.descriptor) + } + } } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontendFacade.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontendFacade.kt index 771ab9dc950..ef6043af79a 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontendFacade.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/classic/ClassicFrontendFacade.kt @@ -346,12 +346,10 @@ class ClassicFrontendFacade( dependencyDescriptors: List, friendsDescriptors: List, ): AnalysisResult { - val needsKotlinTest = ConfigurationDirectives.WITH_STDLIB in module.directives - val runtimeKlibsNames = listOfNotNull( System.getProperty("kotlin.wasm.stdlib.path")!!, - System.getProperty("kotlin.wasm.kotlin.test.path")!!.takeIf { needsKotlinTest } + System.getProperty("kotlin.wasm.kotlin.test.path")!! ).map { File(it).absolutePath } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrWasmResultsConverter.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrWasmResultsConverter.kt new file mode 100644 index 00000000000..0e3e3cdb916 --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/Fir2IrWasmResultsConverter.kt @@ -0,0 +1,228 @@ +/* + * 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.test.frontend.fir + +import org.jetbrains.kotlin.KtSourceFile +import org.jetbrains.kotlin.backend.common.extensions.IrPluginContext +import org.jetbrains.kotlin.backend.common.serialization.signature.IdSignatureDescriptor +import org.jetbrains.kotlin.builtins.DefaultBuiltIns +import org.jetbrains.kotlin.builtins.KotlinBuiltIns +import org.jetbrains.kotlin.config.CommonConfigurationKeys +import org.jetbrains.kotlin.config.CompilerConfiguration +import org.jetbrains.kotlin.config.LanguageVersionSettings +import org.jetbrains.kotlin.config.languageVersionSettings +import org.jetbrains.kotlin.constant.EvaluatedConstTracker +import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl +import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory +import org.jetbrains.kotlin.fir.AbstractFirAnalyzerFacade +import org.jetbrains.kotlin.fir.FirAnalyzerFacade +import org.jetbrains.kotlin.fir.backend.* +import org.jetbrains.kotlin.fir.backend.js.FirJsKotlinMangler +import org.jetbrains.kotlin.fir.backend.jvm.Fir2IrJvmSpecialAnnotationSymbolProvider +import org.jetbrains.kotlin.fir.declarations.FirDeclaration +import org.jetbrains.kotlin.fir.declarations.FirFile +import org.jetbrains.kotlin.fir.descriptors.FirModuleDescriptor +import org.jetbrains.kotlin.fir.serialization.FirKLibSerializerExtension +import org.jetbrains.kotlin.fir.serialization.serializeSingleFirFile +import org.jetbrains.kotlin.incremental.components.LookupTracker +import org.jetbrains.kotlin.ir.backend.js.JsFactories +import org.jetbrains.kotlin.ir.backend.js.getSerializedData +import org.jetbrains.kotlin.ir.backend.js.incrementalDataProvider +import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsManglerDesc +import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsManglerIr +import org.jetbrains.kotlin.ir.declarations.IrModuleFragment +import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl +import org.jetbrains.kotlin.ir.util.KotlinMangler +import org.jetbrains.kotlin.library.metadata.resolver.KotlinResolvedLibrary +import org.jetbrains.kotlin.library.unresolvedDependencies +import org.jetbrains.kotlin.storage.LockBasedStorageManager +import org.jetbrains.kotlin.test.backend.ir.IrBackendInput +import org.jetbrains.kotlin.test.directives.CodegenTestDirectives +import org.jetbrains.kotlin.test.model.BackendKinds +import org.jetbrains.kotlin.test.model.Frontend2BackendConverter +import org.jetbrains.kotlin.test.model.FrontendKinds +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.compilerConfigurationProvider +import org.jetbrains.kotlin.test.services.libraryProvider +import org.jetbrains.kotlin.utils.metadataVersion + +class Fir2IrWasmResultsConverter( + testServices: TestServices +) : Frontend2BackendConverter( + testServices, + FrontendKinds.FIR, + BackendKinds.IrBackend +) { + + override fun transform(module: TestModule, inputArtifact: FirOutputArtifact): IrBackendInput? = + try { + transformInternal(module, inputArtifact) + } catch (e: Throwable) { + if (CodegenTestDirectives.IGNORE_FIR2IR_EXCEPTIONS_IF_FIR_CONTAINS_ERRORS in module.directives && inputArtifact.hasErrors) { + null + } else { + throw e + } + } + + private fun transformInternal( + module: TestModule, + inputArtifact: FirOutputArtifact + ): IrBackendInput { + val configuration = testServices.compilerConfigurationProvider.getCompilerConfiguration(module) + + lateinit var mainIrPart: IrModuleFragment + val dependentIrParts = mutableListOf() + val sourceFiles = mutableListOf() + val firFilesAndComponentsBySourceFile = mutableMapOf>() + lateinit var mainPluginContext: IrPluginContext + var irBuiltIns: IrBuiltInsOverFir? = null + + val commonMemberStorage = Fir2IrCommonMemberStorage(IdSignatureDescriptor(JsManglerDesc), FirJsKotlinMangler()) + + val irMangler = JsManglerIr + + for ((index, part) in inputArtifact.partsForDependsOnModules.withIndex()) { + val (irModuleFragment, components, pluginContext) = + part.firAnalyzerFacade.convertToWasmIr( + part.firFiles.values, + fir2IrExtensions = Fir2IrExtensions.Default, + module, + configuration, + testServices, + commonMemberStorage, + irBuiltIns, + irMangler, + generateSignatures = true, + ) + irBuiltIns = components.irBuiltIns + mainPluginContext = pluginContext + + if (index < inputArtifact.partsForDependsOnModules.size - 1) { + dependentIrParts.add(irModuleFragment) + } else { + mainIrPart = irModuleFragment + } + + sourceFiles.addAll(part.firFiles.mapNotNull { it.value.sourceFile }) + + for (firFile in part.firFiles.values) { + firFilesAndComponentsBySourceFile[firFile.sourceFile!!] = firFile to components + } + } + + val metadataVersion = configuration.metadataVersion(module.languageVersionSettings.languageVersion) + + var actualizedExpectDeclarations: Set? = null + + return IrBackendInput.WasmBackendInput( + mainIrPart, + dependentIrParts, + mainPluginContext, + sourceFiles, + configuration.incrementalDataProvider?.getSerializedData(sourceFiles) ?: emptyList(), + expectDescriptorToSymbol = mutableMapOf(), + diagnosticReporter = DiagnosticReporterFactory.createReporter(), + hasErrors = inputArtifact.hasErrors, + descriptorMangler = commonMemberStorage.symbolTable.signaturer.mangler, + irMangler = irMangler, + firMangler = commonMemberStorage.firSignatureComposer.mangler, + ) { file, irActualizedResult -> + val (firFile, components) = firFilesAndComponentsBySourceFile[file] + ?: error("cannot find FIR file by source file ${file.name} (${file.path})") + if (actualizedExpectDeclarations == null && irActualizedResult != null) { + actualizedExpectDeclarations = irActualizedResult.extractFirDeclarations() + } + serializeSingleFirFile( + firFile, + components.session, + components.scopeSession, + actualizedExpectDeclarations, + FirKLibSerializerExtension( + components.session, metadataVersion, + ConstValueProviderImpl(components), + allowErrorTypes = false, exportKDoc = false, + additionalAnnotationsProvider = null, + ), + configuration.languageVersionSettings, + ) + } + } +} + +fun AbstractFirAnalyzerFacade.convertToWasmIr( + firFiles: Collection, + fir2IrExtensions: Fir2IrExtensions, + module: TestModule, + configuration: CompilerConfiguration, + testServices: TestServices, + commonMemberStorage: Fir2IrCommonMemberStorage, + irBuiltIns: IrBuiltInsOverFir?, + irMangler: KotlinMangler.IrMangler, + generateSignatures: Boolean +): Fir2IrResult { + this as FirAnalyzerFacade + // TODO: consider avoiding repeated libraries resolution + val libraries = resolveWasmLibraries(module, testServices, configuration) + val (dependencies, builtIns) = loadResolvedLibraries(libraries, configuration.languageVersionSettings, testServices) + + val fir2IrConfiguration = Fir2IrConfiguration( + languageVersionSettings = configuration.languageVersionSettings, + linkViaSignatures = generateSignatures, + evaluatedConstTracker = configuration + .putIfAbsent(CommonConfigurationKeys.EVALUATED_CONST_TRACKER, EvaluatedConstTracker.create()), + inlineConstTracker = null, + ) + return Fir2IrConverter.createModuleFragmentWithSignaturesIfNeeded( + session, scopeSession, firFiles.toList(), + fir2IrExtensions, + fir2IrConfiguration, + irMangler, IrFactoryImpl, + Fir2IrVisibilityConverter.Default, + Fir2IrJvmSpecialAnnotationSymbolProvider(), // TODO: replace with appropriate (probably empty) implementation + irGeneratorExtensions, + kotlinBuiltIns = builtIns ?: DefaultBuiltIns.Instance, // TODO: consider passing externally, + commonMemberStorage = commonMemberStorage, + initializedIrBuiltIns = irBuiltIns + ).also { + (it.irModuleFragment.descriptor as? FirModuleDescriptor)?.let { it.allDependencyModules = dependencies } + } +} + +private fun loadResolvedLibraries( + resolvedLibraries: List, + languageVersionSettings: LanguageVersionSettings, + testServices: TestServices +): Pair, KotlinBuiltIns?> { + var builtInsModule: KotlinBuiltIns? = null + val dependencies = mutableListOf() + + return resolvedLibraries.map { resolvedLibrary -> + // resolvedLibrary.library.libraryName in fact resolves to (modified) file path, which is confising and maybe should be refactored + testServices.libraryProvider.getOrCreateStdlibByPath(resolvedLibrary.library.libraryName) { + // TODO: check safety of the approach of creating a separate storage manager per library + val storageManager = LockBasedStorageManager("ModulesStructure") + + val moduleDescriptor = JsFactories.DefaultDeserializedDescriptorFactory.createDescriptorOptionalBuiltIns( + resolvedLibrary.library, + languageVersionSettings, + storageManager, + builtInsModule, + packageAccessHandler = null, + lookupTracker = LookupTracker.DO_NOTHING + ) + dependencies += moduleDescriptor + moduleDescriptor.setDependencies(ArrayList(dependencies)) + + Pair(moduleDescriptor, resolvedLibrary.library) + }.also { + val isBuiltIns = resolvedLibrary.library.unresolvedDependencies.isEmpty() + if (isBuiltIns) builtInsModule = it.builtIns + } + } to builtInsModule +} diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirFrontendFacade.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirFrontendFacade.kt index d09bcd81a93..aac28d6a75e 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirFrontendFacade.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/FirFrontendFacade.kt @@ -41,6 +41,7 @@ import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.platform.TargetPlatform import org.jetbrains.kotlin.platform.isCommon import org.jetbrains.kotlin.platform.isJs +import org.jetbrains.kotlin.platform.isWasm import org.jetbrains.kotlin.platform.jvm.isJvm import org.jetbrains.kotlin.platform.konan.isNative import org.jetbrains.kotlin.psi.KtFile @@ -55,6 +56,7 @@ import org.jetbrains.kotlin.test.model.TestModule import org.jetbrains.kotlin.test.runners.lightTreeSyntaxDiagnosticsReporterHolder import org.jetbrains.kotlin.test.services.* import org.jetbrains.kotlin.test.services.configuration.JsEnvironmentConfigurator +import org.jetbrains.kotlin.test.services.configuration.WasmEnvironmentConfigurator import java.nio.file.Paths open class FirFrontendFacade( @@ -240,6 +242,20 @@ open class FirFrontendFacade( registerExtraComponents = ::registerExtraComponents, ) } + module.targetPlatform.isWasm() -> { + projectEnvironment = null + TestFirWasmSessionFactory.createLibrarySession( + moduleName, + sessionProvider, + moduleDataProvider, + module, + testServices, + configuration, + extensionRegistrars, + languageVersionSettings, + registerExtraComponents = ::registerExtraComponents, + ) + } else -> error("Unsupported") } return projectEnvironment @@ -380,6 +396,17 @@ open class FirFrontendFacade( init = sessionConfigurator ) } + targetPlatform.isWasm() -> { + TestFirWasmSessionFactory.createModuleBasedSession( + moduleData, + sessionProvider, + extensionRegistrars, + languageVersionSettings, + null, + registerExtraComponents = ::registerExtraComponents, + sessionConfigurator, + ) + } else -> error("Unsupported") } } @@ -413,6 +440,13 @@ open class FirFrontendFacade( dependencies(transitiveLibraries.map { it.toPath().toAbsolutePath() }) friendDependencies(friendLibraries.map { it.toPath().toAbsolutePath() }) } + targetPlatform.isWasm() -> { + val runtimeKlibsPaths = WasmEnvironmentConfigurator.getRuntimePathsForModule() + val (transitiveLibraries, friendLibraries) = getTransitivesAndFriends(mainModule, testServices) + dependencies(runtimeKlibsPaths.map { Paths.get(it).toAbsolutePath() }) + dependencies(transitiveLibraries.map { it.toPath().toAbsolutePath() }) + friendDependencies(friendLibraries.map { it.toPath().toAbsolutePath() }) + } else -> error("Unsupported") } } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/TestFirWasmSessionFactory.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/TestFirWasmSessionFactory.kt new file mode 100644 index 00000000000..0eb2633979a --- /dev/null +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/TestFirWasmSessionFactory.kt @@ -0,0 +1,88 @@ +/* + * Copyright 2010-2021 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.test.frontend.fir + +import org.jetbrains.kotlin.config.CompilerConfiguration +import org.jetbrains.kotlin.config.LanguageVersionSettings +import org.jetbrains.kotlin.fir.FirModuleData +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.deserialization.ModuleDataProvider +import org.jetbrains.kotlin.fir.extensions.FirExtensionRegistrar +import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider +import org.jetbrains.kotlin.fir.session.FirSessionConfigurator +import org.jetbrains.kotlin.fir.session.FirWasmSessionFactory +import org.jetbrains.kotlin.incremental.components.LookupTracker +import org.jetbrains.kotlin.ir.backend.js.resolverLogger +import org.jetbrains.kotlin.library.metadata.resolver.KotlinResolvedLibrary +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.test.model.DependencyRelation +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.configuration.WasmEnvironmentConfigurator +import java.io.File + +object TestFirWasmSessionFactory { + fun createLibrarySession( + mainModuleName: Name, + sessionProvider: FirProjectSessionProvider, + moduleDataProvider: ModuleDataProvider, + module: TestModule, + testServices: TestServices, + configuration: CompilerConfiguration, + extensionRegistrars: List, + languageVersionSettings: LanguageVersionSettings, + registerExtraComponents: ((FirSession) -> Unit), + ): FirSession { + val resolvedLibraries = resolveLibraries(configuration, getAllWasmDependenciesPaths(module, testServices)) + + return FirWasmSessionFactory.createLibrarySession( + mainModuleName, + resolvedLibraries.map { it.library }, + sessionProvider, + moduleDataProvider, + extensionRegistrars, + languageVersionSettings, + registerExtraComponents, + ) + } + + fun createModuleBasedSession( + mainModuleData: FirModuleData, sessionProvider: FirProjectSessionProvider, extensionRegistrars: List, + languageVersionSettings: LanguageVersionSettings, lookupTracker: LookupTracker?, + registerExtraComponents: ((FirSession) -> Unit), + sessionConfigurator: FirSessionConfigurator.() -> Unit, + ): FirSession = + FirWasmSessionFactory.createModuleBasedSession( + mainModuleData, + sessionProvider, + extensionRegistrars, + languageVersionSettings, + lookupTracker, + icData = null, + registerExtraComponents, + sessionConfigurator + ) +} + +fun resolveWasmLibraries( + module: TestModule, + testServices: TestServices, + configuration: CompilerConfiguration +): List { + return resolveLibraries(configuration, getAllWasmDependenciesPaths(module, testServices)) +} + +fun getAllWasmDependenciesPaths(module: TestModule, testServices: TestServices): List { + val (runtimeKlibsPaths, transitiveLibraries, friendLibraries) = getWasmDependencies(module, testServices) + return runtimeKlibsPaths + transitiveLibraries.map { it.path } + friendLibraries.map { it.path } +} + +fun getWasmDependencies(module: TestModule, testServices: TestServices): Triple, List, List> { + val runtimeKlibsPaths = WasmEnvironmentConfigurator.getRuntimePathsForModule() + val transitiveLibraries = WasmEnvironmentConfigurator.getKlibDependencies(module, testServices, DependencyRelation.RegularDependency) + val friendLibraries = WasmEnvironmentConfigurator.getKlibDependencies(module, testServices, DependencyRelation.FriendDependency) + return Triple(runtimeKlibsPaths, transitiveLibraries, friendLibraries) +} \ No newline at end of file diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/model/ResultingArtifacts.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/model/ResultingArtifacts.kt index 0546cc3144a..e5f721a4745 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/model/ResultingArtifacts.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/model/ResultingArtifacts.kt @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.test.model import org.jetbrains.kotlin.KtSourceFile +import org.jetbrains.kotlin.backend.wasm.WasmCompilerResult import org.jetbrains.kotlin.codegen.ClassFileFactory import org.jetbrains.kotlin.fileClasses.JvmFileClassInfo import org.jetbrains.kotlin.ir.backend.js.CompilerResult @@ -49,6 +50,14 @@ object BinaryArtifacts { get() = ArtifactKinds.Native } + class Wasm( + val compilerResult: WasmCompilerResult, + val compilerResultWithDCE: WasmCompilerResult, + ) : ResultingArtifact.Binary() { + override val kind: BinaryKind + get() = ArtifactKinds.Wasm + } + class KLib(val outputFile: File) : ResultingArtifact.Binary() { override val kind: BinaryKind get() = ArtifactKinds.KLib diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/model/TestArtifactKinds.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/model/TestArtifactKinds.kt index 0a1689c7809..288e8b156e9 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/model/TestArtifactKinds.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/model/TestArtifactKinds.kt @@ -50,6 +50,7 @@ object ArtifactKinds { object Jvm : BinaryKind("JVM") object Js : BinaryKind("JS") object Native : BinaryKind("Native") + object Wasm : BinaryKind("Wasm") object KLib : BinaryKind("KLib") fun fromString(string: String): BinaryKind<*>? { @@ -57,6 +58,7 @@ object ArtifactKinds { "Jvm" -> Jvm "Js" -> Js "Native" -> Native + "Wasm" -> Wasm "KLib" -> KLib else -> null } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/Helpers.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/Helpers.kt index 0fd52f21bb6..f00d6ef9434 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/Helpers.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/Helpers.kt @@ -12,7 +12,7 @@ import org.jetbrains.kotlin.test.model.DependencyRelation import org.jetbrains.kotlin.test.model.TestModule import org.jetbrains.kotlin.test.services.TestServices import org.jetbrains.kotlin.test.services.dependencyProvider -import org.jetbrains.kotlin.test.services.jsLibraryProvider +import org.jetbrains.kotlin.test.services.libraryProvider import java.io.File fun getKlibDependencies(module: TestModule, testServices: TestServices, kind: DependencyRelation): List { @@ -39,5 +39,5 @@ fun getKlibDependencies(module: TestModule, testServices: TestServices, kind: De fun getDependencies(module: TestModule, testServices: TestServices, kind: DependencyRelation): List { return getKlibDependencies(module, testServices, kind) - .map { testServices.jsLibraryProvider.getDescriptorByPath(it.absolutePath) } + .map { testServices.libraryProvider.getDescriptorByPath(it.absolutePath) } } diff --git a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/WasmEnvironmentConfigurator.kt b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/WasmEnvironmentConfigurator.kt index 67ceea0e37e..f66a88221f0 100644 --- a/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/WasmEnvironmentConfigurator.kt +++ b/compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/WasmEnvironmentConfigurator.kt @@ -11,16 +11,19 @@ import org.jetbrains.kotlin.config.CommonConfigurationKeys import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.config.LanguageVersion import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl import org.jetbrains.kotlin.js.config.JSConfigurationKeys import org.jetbrains.kotlin.js.config.SourceMapSourceEmbedding +import org.jetbrains.kotlin.library.KotlinLibrary import org.jetbrains.kotlin.serialization.js.ModuleKind -import org.jetbrains.kotlin.test.directives.JsEnvironmentConfigurationDirectives +import org.jetbrains.kotlin.test.directives.JsEnvironmentConfigurationDirectives.INFER_MAIN_MODULE import org.jetbrains.kotlin.test.directives.JsEnvironmentConfigurationDirectives.EXPECT_ACTUAL_LINKER -import org.jetbrains.kotlin.test.directives.JsEnvironmentConfigurationDirectives.NO_INLINE import org.jetbrains.kotlin.test.directives.JsEnvironmentConfigurationDirectives.PROPERTY_LAZY_INITIALIZATION import org.jetbrains.kotlin.test.directives.JsEnvironmentConfigurationDirectives.SOURCE_MAP_EMBED_SOURCES +import org.jetbrains.kotlin.test.directives.WasmEnvironmentConfigurationDirectives import org.jetbrains.kotlin.test.directives.model.DirectivesContainer import org.jetbrains.kotlin.test.directives.model.RegisteredDirectives +import org.jetbrains.kotlin.test.frontend.classic.moduleDescriptorProvider import org.jetbrains.kotlin.test.model.ArtifactKinds import org.jetbrains.kotlin.test.model.DependencyKind import org.jetbrains.kotlin.test.model.DependencyRelation @@ -30,7 +33,98 @@ import java.io.File class WasmEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfigurator(testServices) { override val directiveContainers: List - get() = listOf(JsEnvironmentConfigurationDirectives) + get() = listOf(WasmEnvironmentConfigurationDirectives) + + companion object { + private const val OUTPUT_KLIB_DIR_NAME = "outputKlibDir" + + fun getRuntimePathsForModule(): List { + return listOf(System.getProperty("kotlin.wasm.stdlib.path")!!, System.getProperty("kotlin.wasm.kotlin.test.path")!!) + } + + fun getKlibDependencies(module: TestModule, testServices: TestServices, kind: DependencyRelation): List { + val visited = mutableSetOf() + fun getRecursive(module: TestModule, relation: DependencyRelation) { + val dependencies = if (relation == DependencyRelation.FriendDependency) { + module.friendDependencies + } else { + module.regularDependencies + } + dependencies + .filter { it.kind != DependencyKind.Source } + .map { testServices.dependencyProvider.getTestModule(it.moduleName) }.forEach { + if (it !in visited) { + visited += it + getRecursive(it, relation) + } + } + } + getRecursive(module, kind) + return visited.map { testServices.dependencyProvider.getArtifact(it, ArtifactKinds.KLib).outputFile } + } + + fun getDependencies(module: TestModule, testServices: TestServices, kind: DependencyRelation): List { + return getKlibDependencies(module, testServices, kind) + .map { testServices.libraryProvider.getDescriptorByPath(it.absolutePath) } + } + + + fun getWasmKlibArtifactPath(testServices: TestServices, moduleName: String): String { + return getWasmKlibOutputDir(testServices).absolutePath + File.separator + JsEnvironmentConfigurator.getJsArtifactSimpleName( + testServices, + moduleName + ) + } + + fun getWasmKlibOutputDir(testServices: TestServices): File { + return testServices.temporaryDirectoryManager.getOrCreateTempDirectory(OUTPUT_KLIB_DIR_NAME) + } + + fun getAllRecursiveDependenciesFor(module: TestModule, testServices: TestServices): Set { + val visited = mutableSetOf() + fun getRecursive(descriptor: ModuleDescriptor) { + descriptor.allDependencyModules.forEach { + if (it is ModuleDescriptorImpl && it !in visited) { + visited += it + getRecursive(it) + } + } + } + + getRecursive(testServices.moduleDescriptorProvider.getModuleDescriptor(module)) + return visited + } + + fun getAllRecursiveLibrariesFor(module: TestModule, testServices: TestServices): Map { + val dependencies = getAllRecursiveDependenciesFor(module, testServices) + return dependencies.associateBy { testServices.libraryProvider.getCompiledLibraryByDescriptor(it) } + } + + fun getAllDependenciesMappingFor(module: TestModule, testServices: TestServices): Map> { + val allRecursiveLibraries: Map = + getAllRecursiveLibrariesFor(module, testServices) + val m2l = allRecursiveLibraries.map { it.value to it.key }.toMap() + + return allRecursiveLibraries.keys.associateWith { m -> + val descriptor = allRecursiveLibraries[m] ?: error("No descriptor found for library ${m.libraryName}") + descriptor.allDependencyModules.filter { it != descriptor }.map { m2l.getValue(it) } + } + } + + fun getMainModule(testServices: TestServices): TestModule { + val modules = testServices.moduleStructure.modules + val inferMainModule = INFER_MAIN_MODULE in testServices.moduleStructure.allDirectives + return when { + inferMainModule -> modules.last() + else -> modules.singleOrNull { it.name == ModuleStructureExtractor.DEFAULT_MODULE_NAME } ?: modules.last() + } + } + + fun isMainModule(module: TestModule, testServices: TestServices): Boolean { + return module == getMainModule(testServices) + } + } + override fun provideAdditionalAnalysisFlags( directives: RegisteredDirectives, @@ -48,11 +142,11 @@ class WasmEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfi override fun configureCompilerConfiguration(configuration: CompilerConfiguration, module: TestModule) { val registeredDirectives = module.directives configuration.put(JSConfigurationKeys.MODULE_KIND, ModuleKind.ES) - - val noInline = registeredDirectives.contains(NO_INLINE) - configuration.put(CommonConfigurationKeys.DISABLE_INLINE, noInline) configuration.put(CommonConfigurationKeys.MODULE_NAME, module.name) + configuration.put(JSConfigurationKeys.WASM_ENABLE_ASSERTS, true) + configuration.put(JSConfigurationKeys.WASM_ENABLE_ARRAY_RANGE_CHECKS, true) + val sourceDirs = module.files.map { it.originalFile.parent }.distinct() configuration.put(JSConfigurationKeys.SOURCE_MAP_SOURCE_ROOTS, sourceDirs) configuration.put(JSConfigurationKeys.SOURCE_MAP, true) diff --git a/wasm/wasm.tests/build.gradle.kts b/wasm/wasm.tests/build.gradle.kts index cded54174e6..803a170203a 100644 --- a/wasm/wasm.tests/build.gradle.kts +++ b/wasm/wasm.tests/build.gradle.kts @@ -133,23 +133,18 @@ val generateTests by generator("org.jetbrains.kotlin.generators.tests.GenerateWa dependsOn(":compiler:generateTestData") } -projectTest(parallel = true) { - workingDir = rootDir - exclude("**/diagnostics/*.class") - setupV8() - setupSpiderMonkey() - setupWasmStdlib() - setupGradlePropertiesForwarding() - systemProperty("kotlin.wasm.test.root.out.dir", "$buildDir/") -} - projectTest( - taskName = "diagnosticsTest", + taskName = "test", parallel = true, jUnitMode = JUnitMode.JUnit5 ) { workingDir = rootDir include("**/diagnostics/*.class") + include("**/FirWasm*.class") + include("**/K1Wasm*.class") + include("**/Wasm*.class") + setupV8() + setupSpiderMonkey() useJUnitPlatform() setupWasmStdlib() setupGradlePropertiesForwarding() diff --git a/wasm/wasm.tests/test/org/jetbrains/kotlin/generators/tests/GenerateWasmTests.kt b/wasm/wasm.tests/test/org/jetbrains/kotlin/generators/tests/GenerateWasmTests.kt index 5a9df8c03ad..e43a3b1e057 100644 --- a/wasm/wasm.tests/test/org/jetbrains/kotlin/generators/tests/GenerateWasmTests.kt +++ b/wasm/wasm.tests/test/org/jetbrains/kotlin/generators/tests/GenerateWasmTests.kt @@ -1,60 +1,29 @@ /* - * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Copyright 2010-2023 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.generators.tests import org.jetbrains.kotlin.generators.generateTestGroupSuiteWithJUnit5 -import org.jetbrains.kotlin.generators.impl.generateTestGroupSuite -import org.jetbrains.kotlin.test.TargetBackend import org.jetbrains.kotlin.wasm.test.* import org.jetbrains.kotlin.wasm.test.diagnostics.AbstractDiagnosticsWasmTest fun main(args: Array) { System.setProperty("java.awt.headless", "true") + // Common configuration shared between K1 and K2 tests: val jvmOnlyBoxTests = listOf( "compileKotlinAgainstKotlin", ) - - generateTestGroupSuite(args) { - val jsTranslatorTestPattern = "^([^_](.+))\\.kt$" - testGroup("wasm/wasm.tests/tests-gen", "js/js.translator/testData", testRunnerMethodName = "runTest0") { - testClass { - model("box/main", pattern = jsTranslatorTestPattern, targetBackend = TargetBackend.WASM) - model("box/native/", pattern = jsTranslatorTestPattern, targetBackend = TargetBackend.WASM) - model("box/esModules/", pattern = jsTranslatorTestPattern, targetBackend = TargetBackend.WASM, - excludeDirs = listOf( - // JsExport is not supported for classes - "jsExport", "native", "export", - // Multimodal infra is not supported. Also, we don't use ES modules for cross-module refs in Wasm - "crossModuleRef", "crossModuleRefPerFile", "crossModuleRefPerModule" - ) - ) - model("box/jsQualifier/", pattern = jsTranslatorTestPattern, targetBackend = TargetBackend.WASM) - model("box/reflection/", pattern = "^(findAssociatedObject(InSeparatedFile)?)\\.kt$", targetBackend = TargetBackend.WASM) - } - - testClass { - model("box/kotlin.test/", pattern = jsTranslatorTestPattern, targetBackend = TargetBackend.WASM) - } - } - - testGroup("wasm/wasm.tests/tests-gen", "compiler/testData", testRunnerMethodName = "runTest0") { - testClass { - model("codegen/box", targetBackend = TargetBackend.WASM, pattern = jsTranslatorTestPattern, excludeDirs = jvmOnlyBoxTests) - } - - testClass { - model("codegen/boxInline", targetBackend = TargetBackend.WASM) - } - - testClass { - model("codegen/boxWasmJsInterop", targetBackend = TargetBackend.WASM) - } - } - } + val jsTranslatorTestPattern = "^([^_](.+))\\.kt$" + val jsTranslatorReflectionPattern = "^(findAssociatedObject(InSeparatedFile)?)\\.kt$" + val jsTranslatorEsModulesExcludedDirs = listOf( + // JsExport is not supported for classes + "jsExport", "native", "export", + // Multimodal infra is not supported. Also, we don't use ES modules for cross-module refs in Wasm + "crossModuleRef", "crossModuleRefPerFile", "crossModuleRefPerModule" + ) generateTestGroupSuiteWithJUnit5(args) { testGroup("wasm/wasm.tests/tests-gen", "compiler/testData") { @@ -62,5 +31,55 @@ fun main(args: Array) { model("diagnostics/wasmTests") } } + + testGroup("wasm/wasm.tests/tests-gen", "js/js.translator/testData", testRunnerMethodName = "runTest0") { + testClass { + model("box/main", pattern = jsTranslatorTestPattern) + model("box/native/", pattern = jsTranslatorTestPattern) + model("box/esModules/", pattern = jsTranslatorTestPattern, excludeDirs = jsTranslatorEsModulesExcludedDirs) + model("box/jsQualifier/", pattern = jsTranslatorTestPattern) + model("box/reflection/", pattern = jsTranslatorReflectionPattern) + model("box/kotlin.test/", pattern = jsTranslatorTestPattern) + } + } + + testGroup("wasm/wasm.tests/tests-gen", "compiler/testData", testRunnerMethodName = "runTest0") { + testClass { + model("codegen/box", pattern = jsTranslatorTestPattern, excludeDirs = jvmOnlyBoxTests) + } + + testClass { + model("codegen/boxInline") + } + + testClass { + model("codegen/boxWasmJsInterop") + } + } + + testGroup("wasm/wasm.tests/tests-gen", "js/js.translator/testData", testRunnerMethodName = "runTest0") { + testClass { + model("box/main", pattern = jsTranslatorTestPattern) + model("box/native/", pattern = jsTranslatorTestPattern) + model("box/esModules/", pattern = jsTranslatorTestPattern, excludeDirs = jsTranslatorEsModulesExcludedDirs) + model("box/jsQualifier/", pattern = jsTranslatorTestPattern) + model("box/reflection/", pattern = jsTranslatorReflectionPattern) + model("box/kotlin.test/", pattern = jsTranslatorTestPattern) + } + } + + testGroup("wasm/wasm.tests/tests-gen", "compiler/testData", testRunnerMethodName = "runTest0") { + testClass { + model("codegen/box", pattern = jsTranslatorTestPattern, excludeDirs = jvmOnlyBoxTests) + } + + testClass { + model("codegen/boxInline") + } + + testClass { + model("codegen/boxWasmJsInterop") + } + } } } \ No newline at end of file diff --git a/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/AbstractFirWasmTest.kt b/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/AbstractFirWasmTest.kt new file mode 100644 index 00000000000..a258b9f905b --- /dev/null +++ b/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/AbstractFirWasmTest.kt @@ -0,0 +1,92 @@ +/* + * Copyright 2010-2023 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.wasm.test + +import org.jetbrains.kotlin.test.Constructor +import org.jetbrains.kotlin.test.FirParser +import org.jetbrains.kotlin.test.TargetBackend +import org.jetbrains.kotlin.test.backend.ir.IrBackendInput +import org.jetbrains.kotlin.test.builders.* +import org.jetbrains.kotlin.test.directives.DiagnosticsDirectives +import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives +import org.jetbrains.kotlin.test.directives.LanguageSettingsDirectives +import org.jetbrains.kotlin.test.frontend.fir.* +import org.jetbrains.kotlin.test.frontend.fir.handlers.* +import org.jetbrains.kotlin.test.model.* +import org.jetbrains.kotlin.test.runners.codegen.commonFirHandlersForCodegenTest +import org.jetbrains.kotlin.wasm.test.converters.FirWasmKlibBackendFacade +import org.jetbrains.kotlin.wasm.test.converters.WasmBackendFacade + + +open class AbstractFirWasmTest( + pathToTestDir: String, + testGroupOutputDirPrefix: String, +) : AbstractWasmBlackBoxCodegenTestBase( + FrontendKinds.FIR, TargetBackend.WASM, pathToTestDir, testGroupOutputDirPrefix +) { + override val frontendFacade: Constructor> + get() = ::FirFrontendFacade + + override val frontendToBackendConverter: Constructor> + get() = ::Fir2IrWasmResultsConverter + + override val backendFacade: Constructor> + get() = ::FirWasmKlibBackendFacade + + override val afterBackendFacade: Constructor> + get() = ::WasmBackendFacade + + override fun configure(builder: TestConfigurationBuilder) { + super.configure(builder) + with(builder) { + defaultDirectives { + +LanguageSettingsDirectives.ALLOW_KOTLIN_PACKAGE + DiagnosticsDirectives.DIAGNOSTICS with listOf("-infos") + FirDiagnosticsDirectives.FIR_PARSER with FirParser.Psi + } + + firHandlersStep { + useHandlers( + ::FirDumpHandler, + ::FirCfgDumpHandler, + ::FirCfgConsistencyHandler, + ::FirResolvedTypesVerifier, + ) + } + } + } +} + +open class AbstractFirWasmCodegenBoxTest : AbstractFirWasmTest( + pathToTestDir = "compiler/testData/codegen/box/", + testGroupOutputDirPrefix = "codegen/firBox/" +) { + override fun configure(builder: TestConfigurationBuilder) { + super.configure(builder) + builder.configureFirHandlersStep { + commonFirHandlersForCodegenTest() + } + + builder.useAfterAnalysisCheckers( + ::FirMetaInfoDiffSuppressor + ) + } +} + +open class AbstractFirWasmCodegenBoxInlineTest : AbstractFirWasmTest( + "compiler/testData/codegen/boxInline/", + "codegen/firBoxInline/" +) + +open class AbstractFirWasmCodegenWasmJsInteropTest : AbstractFirWasmTest( + "compiler/testData/codegen/wasmJsInterop", + "codegen/firWasmJsInterop" +) + +open class AbstractFirWasmJsTranslatorTest : AbstractFirWasmTest( + "js/js.translator/testData/box/", + "js.translator/firBox" +) diff --git a/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/AbstractK1WasmTest.kt b/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/AbstractK1WasmTest.kt new file mode 100644 index 00000000000..96411d7a099 --- /dev/null +++ b/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/AbstractK1WasmTest.kt @@ -0,0 +1,55 @@ +/* + * Copyright 2010-2023 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.wasm.test + +import org.jetbrains.kotlin.test.Constructor +import org.jetbrains.kotlin.test.TargetBackend +import org.jetbrains.kotlin.test.backend.ir.IrBackendInput +import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontend2IrConverter +import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendFacade +import org.jetbrains.kotlin.test.frontend.classic.ClassicFrontendOutputArtifact +import org.jetbrains.kotlin.test.model.* +import org.jetbrains.kotlin.wasm.test.converters.FirWasmKlibBackendFacade +import org.jetbrains.kotlin.wasm.test.converters.WasmBackendFacade + +abstract class AbstractK1WasmTest( + pathToTestDir: String, + testGroupOutputDirPrefix: String, +) : AbstractWasmBlackBoxCodegenTestBase( + FrontendKinds.ClassicFrontend, TargetBackend.WASM, pathToTestDir, testGroupOutputDirPrefix +) { + override val frontendFacade: Constructor> + get() = ::ClassicFrontendFacade + + override val frontendToBackendConverter: Constructor> + get() = ::ClassicFrontend2IrConverter + + override val backendFacade: Constructor> + get() = ::FirWasmKlibBackendFacade + + override val afterBackendFacade: Constructor> + get() = ::WasmBackendFacade +} + +open class AbstractK1WasmCodegenBoxTest : AbstractK1WasmTest( + "compiler/testData/codegen/box/", + "codegen/k1Box/" +) + +open class AbstractK1WasmCodegenBoxInlineTest : AbstractK1WasmTest( + "compiler/testData/codegen/boxInline/", + "codegen/k1BoxInline/" +) + +open class AbstractK1WasmCodegenWasmJsInteropTest : AbstractK1WasmTest( + "compiler/testData/codegen/wasmJsInterop", + "codegen/k1WasmJsInteropBox" +) + +open class AbstractK1WasmJsTranslatorTest : AbstractK1WasmTest( + "js/js.translator/testData/box/", + "js.translator/k1Box" +) diff --git a/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/AbstractWasmBlackBoxCodegenTestBase.kt b/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/AbstractWasmBlackBoxCodegenTestBase.kt new file mode 100644 index 00000000000..31f96e054ca --- /dev/null +++ b/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/AbstractWasmBlackBoxCodegenTestBase.kt @@ -0,0 +1,112 @@ +/* + * Copyright 2010-2023 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.wasm.test + +import org.jetbrains.kotlin.platform.wasm.WasmPlatforms +import org.jetbrains.kotlin.test.Constructor +import org.jetbrains.kotlin.test.TargetBackend +import org.jetbrains.kotlin.test.backend.BlackBoxCodegenSuppressor +import org.jetbrains.kotlin.test.backend.handlers.KlibInterpreterDumpHandler +import org.jetbrains.kotlin.test.backend.handlers.WasmIrInterpreterDumpHandler +import org.jetbrains.kotlin.test.builders.* +import org.jetbrains.kotlin.test.directives.DiagnosticsDirectives +import org.jetbrains.kotlin.test.directives.DiagnosticsDirectives.DIAGNOSTICS +import org.jetbrains.kotlin.test.directives.WasmEnvironmentConfigurationDirectives +import org.jetbrains.kotlin.test.frontend.classic.handlers.ClassicDiagnosticsHandler +import org.jetbrains.kotlin.test.frontend.fir.handlers.FirDiagnosticsHandler +import org.jetbrains.kotlin.test.model.* +import org.jetbrains.kotlin.test.runners.AbstractKotlinCompilerWithTargetBackendTest +import org.jetbrains.kotlin.test.runners.codegen.commonClassicFrontendHandlersForCodegenTest +import org.jetbrains.kotlin.test.services.LibraryProvider +import org.jetbrains.kotlin.test.services.configuration.CommonEnvironmentConfigurator +import org.jetbrains.kotlin.test.services.configuration.WasmEnvironmentConfigurator +import org.jetbrains.kotlin.test.services.sourceProviders.CoroutineHelpersSourceFilesProvider +import org.jetbrains.kotlin.wasm.test.handlers.WasmBoxRunner + +abstract class AbstractWasmBlackBoxCodegenTestBase, I : ResultingArtifact.BackendInput, A : ResultingArtifact.Binary>( + private val targetFrontend: FrontendKind, + targetBackend: TargetBackend, + private val pathToTestDir: String, + private val testGroupOutputDirPrefix: String, +) : AbstractKotlinCompilerWithTargetBackendTest(targetBackend) { + abstract val frontendFacade: Constructor> + abstract val frontendToBackendConverter: Constructor> + abstract val backendFacade: Constructor> + abstract val afterBackendFacade: Constructor> + + override fun TestConfigurationBuilder.configuration() { + globalDefaults { + frontend = targetFrontend + targetPlatform = WasmPlatforms.Default + dependencyKind = DependencyKind.Binary + } + + val pathToRootOutputDir = System.getProperty("kotlin.wasm.test.root.out.dir") ?: error("'kotlin.wasm.test.root.out.dir' is not set") + defaultDirectives { + +DiagnosticsDirectives.REPORT_ONLY_EXPLICITLY_DEFINED_DEBUG_INFO + WasmEnvironmentConfigurationDirectives.PATH_TO_ROOT_OUTPUT_DIR with pathToRootOutputDir + WasmEnvironmentConfigurationDirectives.PATH_TO_TEST_DIR with pathToTestDir + WasmEnvironmentConfigurationDirectives.TEST_GROUP_OUTPUT_DIR_PREFIX with testGroupOutputDirPrefix + } + + forTestsNotMatching("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/*") { + defaultDirectives { + DIAGNOSTICS with "-warnings" + } + } + + forTestsNotMatching("compiler/testData/codegen/boxError/*") { + enableMetaInfoHandler() + } + + useConfigurators( + ::WasmEnvironmentConfigurator, + ) + + useAdditionalSourceProviders( + ::WasmAdditionalSourceProvider, + ::CoroutineHelpersSourceFilesProvider, + ) + + useAdditionalService(::LibraryProvider) + + useAfterAnalysisCheckers( + ::WasmFailingTestSuppressor, + ::BlackBoxCodegenSuppressor, + ) + + facadeStep(frontendFacade) + classicFrontendHandlersStep { + commonClassicFrontendHandlersForCodegenTest() + useHandlers(::ClassicDiagnosticsHandler) + } + + firHandlersStep { + useHandlers(::FirDiagnosticsHandler) + } + + facadeStep(frontendToBackendConverter) + irHandlersStep() + + facadeStep(backendFacade) + klibArtifactsHandlersStep() + facadeStep(afterBackendFacade) + + forTestsMatching("compiler/testData/codegen/box/involvesIrInterpreter/*") { + enableMetaInfoHandler() + configureKlibArtifactsHandlersStep { + useHandlers(::KlibInterpreterDumpHandler) + } + configureWasmArtifactsHandlersStep { + useHandlers(::WasmIrInterpreterDumpHandler) + } + } + + wasmArtifactsHandlersStep { + useHandlers(::WasmBoxRunner) + } + } +} diff --git a/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/BasicWasmBoxTest.kt b/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/BasicWasmBoxTest.kt deleted file mode 100644 index 97f74e04cef..00000000000 --- a/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/BasicWasmBoxTest.kt +++ /dev/null @@ -1,416 +0,0 @@ -/* - * Copyright 2010-2021 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.wasm.test - -import com.intellij.openapi.util.io.FileUtil -import com.intellij.openapi.vfs.StandardFileSystems -import com.intellij.openapi.vfs.VirtualFileManager -import com.intellij.psi.PsiManager -import org.jetbrains.kotlin.ObsoleteTestInfrastructure -import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig -import org.jetbrains.kotlin.backend.common.phaser.toPhaseMap -import org.jetbrains.kotlin.backend.wasm.* -import org.jetbrains.kotlin.backend.wasm.dce.eliminateDeadDeclarations -import org.jetbrains.kotlin.checkers.parseLanguageVersionSettings -import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport -import org.jetbrains.kotlin.cli.js.klib.TopDownAnalyzerFacadeForWasm -import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles -import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment -import org.jetbrains.kotlin.config.* -import org.jetbrains.kotlin.idea.KotlinFileType -import org.jetbrains.kotlin.ir.backend.js.dce.dumpDeclarationIrSizesIfNeed -import org.jetbrains.kotlin.ir.backend.js.prepareAnalyzedSourceModule -import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl -import org.jetbrains.kotlin.js.config.JSConfigurationKeys -import org.jetbrains.kotlin.js.config.JsConfig -import org.jetbrains.kotlin.js.facade.TranslationUnit -import org.jetbrains.kotlin.wasm.test.tools.WasmVM -import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.psi.KtFile -import org.jetbrains.kotlin.psi.KtNamedFunction -import org.jetbrains.kotlin.psi.KtPsiFactory -import org.jetbrains.kotlin.resolve.CompilerEnvironment -import org.jetbrains.kotlin.serialization.js.ModuleKind -import org.jetbrains.kotlin.test.* -import org.jetbrains.kotlin.test.util.KtTestUtil -import java.io.Closeable -import java.io.File - -abstract class BasicWasmBoxTest( - private val pathToTestDir: String, - testGroupOutputDirPrefix: String, - private val startUnitTests: Boolean = false -) : KotlinTestWithEnvironment() { - - private val pathToRootOutputDir: String = System.getProperty("kotlin.wasm.test.root.out.dir") ?: error("'kotlin.wasm.test.root.out.dir' is not set") - - private val testGroupOutputDirForCompilation = File(pathToRootOutputDir + "out/" + testGroupOutputDirPrefix) - - private val COMMON_FILES_NAME = "_common" - private val COMMON_FILES_DIR = "_commonFiles" - - private val extraLanguageFeatures = mapOf( - LanguageFeature.JsAllowImplementingFunctionInterface to LanguageFeature.State.ENABLED, - ) - - fun doTest(filePath: String) = doTestWithTransformer(filePath) { it } - - @OptIn(ObsoleteTestInfrastructure::class) - fun doTestWithTransformer(filePath: String, transformer: java.util.function.Function) { - val file = File(filePath) - - val outputDirBase = File(getOutputDir(file), getTestName(true)) - val fileContent = transformer.apply(KtTestUtil.doLoadFile(file)) - - TestFileFactoryImpl().use { testFactory -> - val inputFiles: MutableList = TestFiles.createTestFiles(file.name, fileContent, testFactory, true) - val testPackage = testFactory.testPackage - - val languageVersionSettings = inputFiles.firstNotNullOfOrNull { it.languageVersionSettings } - - val kotlinFiles = mutableListOf() - val jsFiles = mutableListOf() - val mjsFiles = mutableListOf() - - var entryMjs: String? = "test.mjs" - - inputFiles.forEach { - val name = it.fileName - when { - name.endsWith(".kt") -> - kotlinFiles += name - - name.endsWith(".js") -> - jsFiles += name - - name.endsWith(".mjs") -> { - mjsFiles += name - val fileName = File(name).name - if (fileName == "entry.mjs") { - entryMjs = fileName - } - } - } - } - - val additionalJsFile = filePath.removeSuffix(".kt") + ".js" - if (File(additionalJsFile).exists()) { - jsFiles += additionalJsFile - } - val additionalMjsFile = filePath.removeSuffix(".kt") + ".mjs" - if (File(additionalMjsFile).exists()) { - mjsFiles += additionalMjsFile - } - - val localCommonFile = file.parent + "/" + COMMON_FILES_NAME + "." + KotlinFileType.EXTENSION - val localCommonFiles = if (File(localCommonFile).exists()) listOf(localCommonFile) else emptyList() - - val globalCommonFilesDir = File(File(pathToTestDir).parent, COMMON_FILES_DIR) - val globalCommonFiles = globalCommonFilesDir.listFiles().orEmpty().map { it.absolutePath } - - val allSourceFiles = kotlinFiles + localCommonFiles + globalCommonFiles - - val psiFiles = createPsiFiles(allSourceFiles.map { File(it).canonicalPath }.sorted()) - val config = createConfig(languageVersionSettings) - val filesToCompile = psiFiles.map { TranslationUnit.SourceFile(it).file } - val debugMode = DebugMode.fromSystemProperty("kotlin.wasm.debugMode") - - val phaseConfig = if (debugMode >= DebugMode.SUPER_DEBUG) { - val dumpOutputDir = File(outputDirBase, "irdump") - println("\n ------ Dumping phases to file://${dumpOutputDir.absolutePath}") - PhaseConfig( - wasmPhases, - dumpToDirectory = dumpOutputDir.path, - toDumpStateAfter = wasmPhases.toPhaseMap().values.toSet(), - ) - } else { - PhaseConfig(wasmPhases) - } - - if (debugMode >= DebugMode.DEBUG) { - println(" ------ KT file://${file.absolutePath}") - } - - val sourceModule = prepareAnalyzedSourceModule( - config.project, - filesToCompile, - config.configuration, - // TODO: Bypass the resolver fow wasm. - listOf(System.getProperty("kotlin.wasm.stdlib.path")!!, System.getProperty("kotlin.wasm.kotlin.test.path")!!), - emptyList(), - AnalyzerWithCompilerReport(config.configuration), - analyzerFacade = TopDownAnalyzerFacadeForWasm - ) - - val (allModules, backendContext) = compileToLoweredIr( - depsDescriptors = sourceModule, - phaseConfig = phaseConfig, - irFactory = IrFactoryImpl, - exportedDeclarations = setOf(FqName.fromSegments(listOfNotNull(testPackage, TEST_FUNCTION))), - propertyLazyInitialization = true, - ) - - val generateWat = debugMode >= DebugMode.DEBUG - val baseFileName = "index" - - val compilerResult = compileWasm( - allModules = allModules, - backendContext = backendContext, - baseFileName = baseFileName, - emitNameSection = true, - allowIncompleteImplementations = false, - generateWat = generateWat, - ) - - eliminateDeadDeclarations(allModules, backendContext) - - dumpDeclarationIrSizesIfNeed(System.getProperty("kotlin.wasm.dump.declaration.ir.size.to.file"), allModules) - - val compilerResultWithDCE = compileWasm( - allModules = allModules, - backendContext = backendContext, - baseFileName = baseFileName, - emitNameSection = true, - allowIncompleteImplementations = true, - generateWat = generateWat, - ) - - val testJsQuiet = """ - let actualResult; - try { - // Use "dynamic import" to catch exception happened during JS & Wasm modules initialization - let jsModule = await import('./index.mjs'); - let wasmExports = jsModule.default; - ${if (startUnitTests) "wasmExports.startUnitTests();" else ""} - actualResult = wasmExports.box(); - } catch(e) { - console.log('Failed with exception!') - console.log('Message: ' + e.message) - console.log('Name: ' + e.name) - console.log('Stack:') - console.log(e.stack) - } - - if (actualResult !== "OK") - throw `Wrong box result '${'$'}{actualResult}'; Expected "OK"`; - """.trimIndent() - - val testJsVerbose = testJsQuiet + """ - console.log('test passed'); - """.trimIndent() - - val testJs = if (debugMode >= DebugMode.DEBUG) testJsVerbose else testJsQuiet - - fun printPathAndSize(mode: String, fileKind: String, path: String, name: String) { - val size = File("$path/$name").length() - println(" ------ $mode $fileKind file://$path/$name $size B") - } - - fun checkExpectedOutputSize(testFileContent: String, testDir: File) { - val expectedSizes = - InTextDirectivesUtils.findListWithPrefixes(testFileContent, "// WASM_DCE_EXPECTED_OUTPUT_SIZE: ") - .map { - val i = it.indexOf(' ') - val extension = it.substring(0, i) - val size = it.substring(i + 1) - extension.trim().lowercase() to size.filter(Char::isDigit).toInt() - } - - val filesByExtension = testDir.listFiles()?.groupBy { it.extension }.orEmpty() - - val errors = expectedSizes.mapNotNull { (extension, expectedSize) -> - val totalSize = filesByExtension[extension].orEmpty().sumOf { it.length() } - - val thresholdPercent = 1 - val thresholdInBytes = expectedSize * thresholdPercent / 100 - - val expectedMinSize = expectedSize - thresholdInBytes - val expectedMaxSize = expectedSize + thresholdInBytes - - val diff = totalSize - expectedSize - - val message = "Total size of $extension files is $totalSize," + - " but expected $expectedSize ∓ $thresholdInBytes [$expectedMinSize .. $expectedMaxSize]." + - " Diff: $diff (${diff * 100 / expectedSize}%)" - - if (debugMode >= DebugMode.DEBUG) { - println(" ------ $message") - } - - if (totalSize !in expectedMinSize..expectedMaxSize) message else null - } - - if (errors.isNotEmpty()) throw AssertionError(errors.joinToString("\n")) - } - - fun writeToFilesAndRunTest(mode: String, res: WasmCompilerResult) { - val dir = File(outputDirBase, mode) - dir.mkdirs() - - writeCompilationResult(res, dir, baseFileName) - File(dir, "test.mjs").writeText(testJs) - - for (mjsPath: String in mjsFiles) { - val mjsFile = File(mjsPath) - File(dir, mjsFile.name).writeText(mjsFile.readText()) - } - - if (debugMode >= DebugMode.DEBUG) { - File(dir, "index.html").writeText( - """ - - - - UNKNOWN - - - - """.trimIndent() - ) - - val path = dir.absolutePath - println(" ------ $mode Wat file://$path/index.wat") - println(" ------ $mode Wasm file://$path/index.wasm") - println(" ------ $mode JS file://$path/index.uninstantiated.mjs") - println(" ------ $mode JS file://$path/index.mjs") - println(" ------ $mode Test file://$path/test.mjs") - val projectName = "kotlin" - println(" ------ $mode HTML http://0.0.0.0:63342/$projectName/${dir.path}/index.html") - for (mjsPath: String in mjsFiles) { - println(" ------ $mode External ESM file://$path/${File(mjsPath).name}") - } - } - - val testFile = file.readText() - - val failsIn = InTextDirectivesUtils.findListWithPrefixes(testFile, "// WASM_FAILS_IN: ") - - val exceptions = listOf(WasmVM.V8, WasmVM.SpiderMonkey).mapNotNull map@{ vm -> - try { - if (debugMode >= DebugMode.DEBUG) { - println(" ------ Run in ${vm.name}" + if (vm.shortName in failsIn) " (expected to fail)" else "") - } - vm.run( - "./${entryMjs}", - jsFiles.map { File(it).absolutePath }, - workingDirectory = dir - ) - if (vm.shortName in failsIn) { - return@map AssertionError("The test expected to fail in ${vm.name}. Please update the testdata.") - } - } catch (e: Throwable) { - if (vm.shortName !in failsIn) { - return@map e - } - } - null - } - - when (exceptions.size) { - 0 -> {} // Everything OK - 1 -> { - throw exceptions.single() - } - else -> { - throw AssertionError("Failed with several exceptions. Look at suppressed exceptions below.").apply { - exceptions.forEach { addSuppressed(it) } - } - } - } - - if (mode == "dce") { - checkExpectedOutputSize(testFile, dir) - } - } - - writeToFilesAndRunTest("dev", compilerResult) - writeToFilesAndRunTest("dce", compilerResultWithDCE) - } - } - - private fun getOutputDir(file: File, testGroupOutputDir: File = testGroupOutputDirForCompilation): File { - val stopFile = File(pathToTestDir) - return generateSequence(file.parentFile) { it.parentFile } - .takeWhile { it != stopFile } - .map { it.name } - .toList().asReversed() - .fold(testGroupOutputDir, ::File) - } - - private fun createConfig(languageVersionSettings: LanguageVersionSettings?): JsConfig { - val configuration = environment.configuration.copy() - configuration.put(CommonConfigurationKeys.MODULE_NAME, TEST_MODULE) - configuration.put(JSConfigurationKeys.WASM_ENABLE_ARRAY_RANGE_CHECKS, true) - configuration.put(JSConfigurationKeys.WASM_ENABLE_ASSERTS, true) - configuration.put(JSConfigurationKeys.MODULE_KIND, ModuleKind.ES) - configuration.languageVersionSettings = languageVersionSettings - ?: LanguageVersionSettingsImpl(LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE, specificFeatures = extraLanguageFeatures) - return JsConfig(project, configuration, CompilerEnvironment, null, null) - } - - @OptIn(ObsoleteTestInfrastructure::class) - private inner class TestFileFactoryImpl : TestFiles.TestFileFactoryNoModules(), Closeable { - override fun create(fileName: String, text: String, directives: Directives): TestFile { - val ktFile = KtPsiFactory(project).createFile(text) - val boxFunction = ktFile.declarations.find { it is KtNamedFunction && it.name == TEST_FUNCTION } - if (boxFunction != null) { - testPackage = ktFile.packageFqName.asString() - if (testPackage?.isEmpty() == true) { - testPackage = null - } - } - - val languageVersionSettings = parseLanguageVersionSettings(directives, extraLanguageFeatures) - - val temporaryFile = File(tmpDir, "WASM_TEST/$fileName") - KtTestUtil.mkdirs(temporaryFile.parentFile) - temporaryFile.writeText(text, Charsets.UTF_8) - - return TestFile(temporaryFile.absolutePath, languageVersionSettings) - } - - var testPackage: String? = null - val tmpDir = KtTestUtil.tmpDir("wasm-tests") - - override fun close() { - FileUtil.delete(tmpDir) - } - } - - private class TestFile(val fileName: String, val languageVersionSettings: LanguageVersionSettings?) - - override fun createEnvironment() = - KotlinCoreEnvironment.createForTests(testRootDisposable, CompilerConfiguration(), EnvironmentConfigFiles.JS_CONFIG_FILES) - - private fun KotlinTestWithEnvironment.createPsiFile(fileName: String): KtFile { - val psiManager = PsiManager.getInstance(project) - val fileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL) - - val file = fileSystem.findFileByPath(fileName) ?: error("File not found: $fileName") - - return psiManager.findFile(file) as KtFile - } - - private fun KotlinTestWithEnvironment.createPsiFiles(fileNames: List): List { - return fileNames.map { this@createPsiFiles.createPsiFile(it) } - } - - companion object { - const val TEST_MODULE = "main" - private const val TEST_FUNCTION = "box" - } -} diff --git a/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/WasmAdditionalSourceProvider.kt b/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/WasmAdditionalSourceProvider.kt new file mode 100644 index 00000000000..027953c627e --- /dev/null +++ b/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/WasmAdditionalSourceProvider.kt @@ -0,0 +1,47 @@ +/* + * Copyright 2010-2023 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.wasm.test + +import org.jetbrains.kotlin.idea.KotlinFileType +import org.jetbrains.kotlin.test.directives.JsEnvironmentConfigurationDirectives +import org.jetbrains.kotlin.test.directives.model.RegisteredDirectives +import org.jetbrains.kotlin.test.model.TestFile +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.AdditionalSourceProvider +import org.jetbrains.kotlin.test.services.TestServices +import java.io.File +import java.io.FileFilter + +class WasmAdditionalSourceProvider(testServices: TestServices) : AdditionalSourceProvider(testServices) { + override fun produceAdditionalFiles(globalDirectives: RegisteredDirectives, module: TestModule): List { + if (JsEnvironmentConfigurationDirectives.NO_COMMON_FILES in module.directives) return emptyList() + return getAdditionalKotlinFiles(module.files.first().originalFile.parent).map { it.toTestFile() } + } + + companion object { + private const val COMMON_FILES_NAME = "_common" + private const val COMMON_FILES_DIR = "_commonFiles/" + private const val COMMON_FILES_DIR_PATH = "js/js.translator/testData/$COMMON_FILES_DIR" + + private fun getFilesInDirectoryByExtension(directory: String, extension: String): List { + val dir = File(directory) + if (!dir.isDirectory) return emptyList() + + return dir.listFiles(FileFilter { it.extension == extension })?.map { it.absolutePath } ?: emptyList() + } + + private fun getAdditionalFiles(directory: String, extension: String): List { + val globalCommonFiles = getFilesInDirectoryByExtension(COMMON_FILES_DIR_PATH, extension).map { File(it) } + val localCommonFilePath = "$directory/$COMMON_FILES_NAME.$extension" + val localCommonFile = File(localCommonFilePath).takeIf { it.exists() } ?: return globalCommonFiles + return globalCommonFiles + localCommonFile + } + + fun getAdditionalKotlinFiles(directory: String): List { + return getAdditionalFiles(directory, KotlinFileType.EXTENSION) + } + } +} \ No newline at end of file diff --git a/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/WasmFailingTestSuppressor.kt b/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/WasmFailingTestSuppressor.kt new file mode 100644 index 00000000000..d2260145d22 --- /dev/null +++ b/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/WasmFailingTestSuppressor.kt @@ -0,0 +1,21 @@ +/* + * Copyright 2010-2023 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.wasm.test + +import org.jetbrains.kotlin.test.WrappedException +import org.jetbrains.kotlin.test.model.AfterAnalysisChecker +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.moduleStructure + +class WasmFailingTestSuppressor(testServices: TestServices) : AfterAnalysisChecker(testServices) { + override fun suppressIfNeeded(failedAssertions: List): List { + val testFile = testServices.moduleStructure.originalTestDataFiles.first() + val failFile = testFile.parentFile.resolve("${testFile.name}.fail").takeIf { it.exists() } + ?: return failedAssertions + if (failedAssertions.any { it is WrappedException.FromFacade }) return emptyList() + return failedAssertions + AssertionError("Fail file exists but no exception was thrown. Please remove ${failFile.name}").wrap() + } +} diff --git a/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/abstractClassesForGeneratedWasmTests.kt b/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/abstractClassesForGeneratedWasmTests.kt deleted file mode 100644 index c90ed2341e8..00000000000 --- a/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/abstractClassesForGeneratedWasmTests.kt +++ /dev/null @@ -1,34 +0,0 @@ -/* - * Copyright 2010-2023 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.wasm.test - -import org.jetbrains.kotlin.wasm.test.BasicWasmBoxTest - -abstract class AbstractIrCodegenBoxWasmTest : BasicWasmBoxTest( - "compiler/testData/codegen/box/", - "codegen/wasmBox/" -) - -abstract class AbstractIrCodegenBoxInlineWasmTest : BasicWasmBoxTest( - "compiler/testData/codegen/boxInline/", - "codegen/wasmBoxInline/" -) - -abstract class AbstractIrCodegenWasmJsInteropWasmTest : BasicWasmBoxTest( - "compiler/testData/codegen/wasmJsInterop", - "codegen/wasmJsInteropJs" -) - -abstract class AbstractJsTranslatorWasmTest : BasicWasmBoxTest( - "js/js.translator/testData/box/", - "js.translator/wasmBox" -) - -abstract class AbstractJsTranslatorUnitWasmTest : BasicWasmBoxTest( - "js/js.translator/testData/box/", - "js.translator/wasmBox", - startUnitTests = true -) \ No newline at end of file diff --git a/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/converters/FirWasmKlibBackendFacade.kt b/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/converters/FirWasmKlibBackendFacade.kt new file mode 100644 index 00000000000..e49431ca41c --- /dev/null +++ b/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/converters/FirWasmKlibBackendFacade.kt @@ -0,0 +1,123 @@ +/* + * Copyright 2010-2023 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.wasm.test.converters + +import org.jetbrains.kotlin.backend.common.CommonKLibResolver +import org.jetbrains.kotlin.backend.common.actualizer.IrActualizer +import org.jetbrains.kotlin.config.CommonConfigurationKeys +import org.jetbrains.kotlin.config.LanguageFeature +import org.jetbrains.kotlin.config.languageVersionSettings +import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl +import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory +import org.jetbrains.kotlin.incremental.components.LookupTracker +import org.jetbrains.kotlin.ir.backend.js.JsFactories +import org.jetbrains.kotlin.ir.backend.js.resolverLogger +import org.jetbrains.kotlin.ir.backend.js.serializeModuleIntoKlib +import org.jetbrains.kotlin.ir.types.IrTypeSystemContextImpl +import org.jetbrains.kotlin.ir.util.IrMessageLogger +import org.jetbrains.kotlin.library.KotlinAbiVersion +import org.jetbrains.kotlin.storage.LockBasedStorageManager +import org.jetbrains.kotlin.test.backend.ir.IrBackendFacade +import org.jetbrains.kotlin.test.backend.ir.IrBackendInput +import org.jetbrains.kotlin.test.frontend.classic.ModuleDescriptorProvider +import org.jetbrains.kotlin.test.frontend.classic.moduleDescriptorProvider +import org.jetbrains.kotlin.test.frontend.fir.getAllWasmDependenciesPaths +import org.jetbrains.kotlin.test.frontend.fir.resolveLibraries +import org.jetbrains.kotlin.test.model.ArtifactKinds +import org.jetbrains.kotlin.test.model.BinaryArtifacts +import org.jetbrains.kotlin.test.model.FrontendKinds +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.* +import org.jetbrains.kotlin.test.services.configuration.WasmEnvironmentConfigurator +import java.io.File + +class FirWasmKlibBackendFacade( + testServices: TestServices, + private val firstTimeCompilation: Boolean +) : IrBackendFacade(testServices, ArtifactKinds.KLib) { + + override val additionalServices: List + get() = listOf(service(::ModuleDescriptorProvider)) + + constructor(testServices: TestServices) : this(testServices, firstTimeCompilation = true) + + override fun shouldRunAnalysis(module: TestModule): Boolean { + return module.backendKind == inputKind + } + + override fun transform(module: TestModule, inputArtifact: IrBackendInput): BinaryArtifacts.KLib { + require(inputArtifact is IrBackendInput.WasmBackendInput) { + "FirWasmKlibBackendFacade expects IrBackendInput.WasmBackendInput as input" + } + + val configuration = testServices.compilerConfigurationProvider.getCompilerConfiguration(module) + val outputFile = WasmEnvironmentConfigurator.getWasmKlibArtifactPath(testServices, module.name) + + // TODO: consider avoiding repeated libraries resolution + val libraries = resolveLibraries(configuration, getAllWasmDependenciesPaths(module, testServices)) + + // TODO: find out how to pass diagnostics to the test infra in this case + val diagnosticReporter = DiagnosticReporterFactory.createReporter() + + if (firstTimeCompilation) { + val irActualizedResult = + if (module.frontendKind == FrontendKinds.FIR && module.languageVersionSettings.supportsFeature(LanguageFeature.MultiPlatformProjects)) { + IrActualizer.actualize( + inputArtifact.irModuleFragment, + inputArtifact.dependentIrModuleFragments, + diagnosticReporter, + IrTypeSystemContextImpl(inputArtifact.irModuleFragment.irBuiltins), + configuration.languageVersionSettings + ) + } else { + null + } + + serializeModuleIntoKlib( + configuration[CommonConfigurationKeys.MODULE_NAME]!!, + configuration, + configuration.get(IrMessageLogger.IR_MESSAGE_LOGGER) ?: IrMessageLogger.None, + inputArtifact.sourceFiles, + klibPath = outputFile, + libraries.map { it.library }, + inputArtifact.irModuleFragment, + inputArtifact.expectDescriptorToSymbol, + cleanFiles = inputArtifact.icData, + nopack = true, + perFile = false, + containsErrorCode = inputArtifact.hasErrors, + abiVersion = KotlinAbiVersion.CURRENT, // TODO get from test file data + jsOutputName = null + ) { + inputArtifact.serializeSingleFile(it, irActualizedResult) + } + } + + // TODO: consider avoiding repeated libraries resolution + val lib = CommonKLibResolver.resolve( + getAllWasmDependenciesPaths(module, testServices) + listOf(outputFile), + configuration.resolverLogger + ).getFullResolvedList().last().library + + val moduleDescriptor = JsFactories.DefaultDeserializedDescriptorFactory.createDescriptorOptionalBuiltIns( + lib, + configuration.languageVersionSettings, + LockBasedStorageManager("ModulesStructure"), + inputArtifact.irModuleFragment.descriptor.builtIns, + packageAccessHandler = null, + lookupTracker = LookupTracker.DO_NOTHING + ) + + moduleDescriptor.setDependencies( + inputArtifact.irModuleFragment.descriptor.allDependencyModules.filterIsInstance() + moduleDescriptor + ) + + testServices.moduleDescriptorProvider.replaceModuleDescriptorForModule(module, moduleDescriptor) + testServices.libraryProvider.setDescriptorAndLibraryByName(outputFile, moduleDescriptor, lib) + + return BinaryArtifacts.KLib(File(outputFile)) + } +} \ No newline at end of file diff --git a/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/converters/WasmBackendFacade.kt b/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/converters/WasmBackendFacade.kt new file mode 100644 index 00000000000..dd2cac06a10 --- /dev/null +++ b/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/converters/WasmBackendFacade.kt @@ -0,0 +1,139 @@ +/* + * Copyright 2010-2023 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.wasm.test.converters + +import org.jetbrains.kotlin.backend.common.phaser.PhaseConfig +import org.jetbrains.kotlin.backend.common.phaser.toPhaseMap +import org.jetbrains.kotlin.backend.wasm.compileToLoweredIr +import org.jetbrains.kotlin.backend.wasm.compileWasm +import org.jetbrains.kotlin.backend.wasm.dce.eliminateDeadDeclarations +import org.jetbrains.kotlin.backend.wasm.wasmPhases +import org.jetbrains.kotlin.ir.backend.js.MainModule +import org.jetbrains.kotlin.ir.backend.js.ModulesStructure +import org.jetbrains.kotlin.ir.backend.js.dce.dumpDeclarationIrSizesIfNeed +import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl +import org.jetbrains.kotlin.ir.linkage.partial.PartialLinkageConfig +import org.jetbrains.kotlin.ir.linkage.partial.PartialLinkageLogLevel +import org.jetbrains.kotlin.ir.linkage.partial.PartialLinkageMode +import org.jetbrains.kotlin.ir.linkage.partial.setupPartialLinkageConfig +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.psi.KtNamedFunction +import org.jetbrains.kotlin.test.DebugMode +import org.jetbrains.kotlin.test.model.AbstractTestFacade +import org.jetbrains.kotlin.test.model.ArtifactKinds +import org.jetbrains.kotlin.test.model.BinaryArtifacts +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.* +import org.jetbrains.kotlin.test.services.configuration.WasmEnvironmentConfigurator +import org.jetbrains.kotlin.wasm.test.handlers.getWasmTestOutputDirectory +import java.io.File + +class WasmBackendFacade( + private val testServices: TestServices +) : AbstractTestFacade() { + + override val inputKind = ArtifactKinds.KLib + override val outputKind = ArtifactKinds.Wasm + + override fun transform(module: TestModule, inputArtifact: BinaryArtifacts.KLib): BinaryArtifacts.Wasm? { + val configuration = testServices.compilerConfigurationProvider.getCompilerConfiguration(module) + + // Enforce PL with the ERROR log level to fail any tests where PL detected any incompatibilities. + configuration.setupPartialLinkageConfig(PartialLinkageConfig(PartialLinkageMode.ENABLE, PartialLinkageLogLevel.ERROR)) + + val isMainModule = WasmEnvironmentConfigurator.isMainModule(module, testServices) + if (!isMainModule) return null + + val debugMode = DebugMode.fromSystemProperty("kotlin.wasm.debugMode") + val phaseConfig = if (debugMode >= DebugMode.SUPER_DEBUG) { + val outputDirBase = testServices.getWasmTestOutputDirectory() + val dumpOutputDir = File(outputDirBase, "irdump") + println("\n ------ Dumping phases to file://${dumpOutputDir.absolutePath}") + PhaseConfig( + wasmPhases, + dumpToDirectory = dumpOutputDir.path, + toDumpStateAfter = wasmPhases.toPhaseMap().values.toSet(), + ) + } else { + PhaseConfig(wasmPhases) + } + + val libraries = listOf( + System.getProperty("kotlin.wasm.stdlib.path")!!, + System.getProperty("kotlin.wasm.kotlin.test.path")!! + ) + WasmEnvironmentConfigurator.getAllRecursiveLibrariesFor(module, testServices).map { it.key.libraryFile.canonicalPath } + + val friendLibraries = emptyList() + val mainModule = MainModule.Klib(inputArtifact.outputFile.absolutePath) + val project = testServices.compilerConfigurationProvider.getProject(module) + val moduleStructure = ModulesStructure( + project, + mainModule, + configuration, + libraries + mainModule.libPath, + friendLibraries + ) + + val testPackage = extractTestPackage(testServices) + val (allModules, backendContext) = compileToLoweredIr( + depsDescriptors = moduleStructure, + phaseConfig = phaseConfig, + irFactory = IrFactoryImpl, + exportedDeclarations = setOf(FqName.fromSegments(listOfNotNull(testPackage, "box"))), + propertyLazyInitialization = true, + ) + val generateWat = debugMode >= DebugMode.DEBUG + val baseFileName = "index" + + val compilerResult = compileWasm( + allModules = allModules, + backendContext = backendContext, + baseFileName = baseFileName, + emitNameSection = true, + allowIncompleteImplementations = false, + generateWat = generateWat, + ) + + eliminateDeadDeclarations(allModules, backendContext) + + dumpDeclarationIrSizesIfNeed(System.getProperty("kotlin.wasm.dump.declaration.ir.size.to.file"), allModules) + + val compilerResultWithDCE = compileWasm( + allModules = allModules, + backendContext = backendContext, + baseFileName = baseFileName, + emitNameSection = true, + allowIncompleteImplementations = true, + generateWat = generateWat, + ) + + return BinaryArtifacts.Wasm( + compilerResult, + compilerResultWithDCE + ) + } + + override fun shouldRunAnalysis(module: TestModule): Boolean { + return WasmEnvironmentConfigurator.isMainModule(module, testServices) + } +} + +fun extractTestPackage(testServices: TestServices): String? { + val ktFiles = testServices.moduleStructure.modules.flatMap { module -> + module.files + .filter { it.isKtFile } + .map { + val project = testServices.compilerConfigurationProvider.getProject(module) + testServices.sourceFileProvider.getKtFileForSourceFile(it, project) + } + } + + val fileWithBoxFunction = ktFiles.find { file -> + file.declarations.find { it is KtNamedFunction && it.name == "box" } != null + } ?: return null + + return fileWithBoxFunction.packageFqName.asString().takeIf { it.isNotEmpty() } +} diff --git a/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/handlers/AbstractWasmArtifactsCollector.kt b/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/handlers/AbstractWasmArtifactsCollector.kt new file mode 100644 index 00000000000..110533639b1 --- /dev/null +++ b/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/handlers/AbstractWasmArtifactsCollector.kt @@ -0,0 +1,19 @@ +/* + * Copyright 2010-2023 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.wasm.test.handlers + +import org.jetbrains.kotlin.test.backend.handlers.WasmBinaryArtifactHandler +import org.jetbrains.kotlin.test.model.BinaryArtifacts +import org.jetbrains.kotlin.test.model.TestModule +import org.jetbrains.kotlin.test.services.TestServices + +abstract class AbstractWasmArtifactsCollector(testServices: TestServices) : WasmBinaryArtifactHandler(testServices) { + val modulesToArtifact = mutableMapOf() + + override fun processModule(module: TestModule, info: BinaryArtifacts.Wasm) { + modulesToArtifact[module] = info + } +} \ No newline at end of file diff --git a/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/handlers/WasmBoxRunner.kt b/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/handlers/WasmBoxRunner.kt new file mode 100644 index 00000000000..9e893b869c7 --- /dev/null +++ b/wasm/wasm.tests/test/org/jetbrains/kotlin/wasm/test/handlers/WasmBoxRunner.kt @@ -0,0 +1,255 @@ +/* + * Copyright 2010-2023 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.wasm.test.handlers + +import org.jetbrains.kotlin.backend.wasm.WasmCompilerResult +import org.jetbrains.kotlin.backend.wasm.writeCompilationResult +import org.jetbrains.kotlin.js.JavaScript +import org.jetbrains.kotlin.test.DebugMode +import org.jetbrains.kotlin.test.InTextDirectivesUtils +import org.jetbrains.kotlin.test.directives.WasmEnvironmentConfigurationDirectives +import org.jetbrains.kotlin.test.directives.WasmEnvironmentConfigurationDirectives.RUN_UNIT_TESTS +import org.jetbrains.kotlin.test.model.TestFile +import org.jetbrains.kotlin.test.services.TestServices +import org.jetbrains.kotlin.test.services.moduleStructure +import org.jetbrains.kotlin.wasm.test.tools.WasmVM +import java.io.File + +class WasmBoxRunner( + testServices: TestServices +) : AbstractWasmArtifactsCollector(testServices) { + override fun processAfterAllModules(someAssertionWasFailed: Boolean) { + if (!someAssertionWasFailed) { + runWasmCode() + } + } + + private fun runWasmCode() { + val artifacts = modulesToArtifact.values.single() + val baseFileName = "index" + val outputDirBase = testServices.getWasmTestOutputDirectory() + + val jsFiles = mutableListOf() + val mjsFiles = mutableListOf() + var entryMjs: String? = "test.mjs" + + testServices.moduleStructure.modules.forEach { m -> + m.files.forEach { file: TestFile -> + val name = file.name + when { + name.endsWith(".js") -> + jsFiles += AdditionalFile(file.name, file.originalContent) + + name.endsWith(".mjs") -> { + mjsFiles += AdditionalFile(file.name, file.originalContent) + if (name == "entry.mjs") { + entryMjs = name + } + } + } + } + } + + val originalFile = testServices.moduleStructure.originalTestDataFiles.first() + + originalFile.parentFile.resolve(originalFile.nameWithoutExtension + JavaScript.DOT_EXTENSION) + .takeIf { it.exists() } + ?.let { + jsFiles += AdditionalFile(it.name, it.readText()) + } + + originalFile.parentFile.resolve(originalFile.nameWithoutExtension + JavaScript.DOT_MODULE_EXTENSION) + .takeIf { it.exists() } + ?.let { + mjsFiles += AdditionalFile(it.name, it.readText()) + } + + val debugMode = DebugMode.fromSystemProperty("kotlin.js.debugMode") + val startUnitTests = RUN_UNIT_TESTS in testServices.moduleStructure.allDirectives + + val testJsQuiet = """ + let actualResult; + try { + // Use "dynamic import" to catch exception happened during JS & Wasm modules initialization + let jsModule = await import('./index.mjs'); + let wasmExports = jsModule.default; + ${if (startUnitTests) "wasmExports.startUnitTests();" else ""} + actualResult = wasmExports.box(); + } catch(e) { + console.log('Failed with exception!') + console.log('Message: ' + e.message) + console.log('Name: ' + e.name) + console.log('Stack:') + console.log(e.stack) + } + + if (actualResult !== "OK") + throw `Wrong box result '${'$'}{actualResult}'; Expected "OK"`; + """.trimIndent() + + val testJsVerbose = testJsQuiet + """ + console.log('test passed'); + """.trimIndent() + + val testJs = if (debugMode >= DebugMode.DEBUG) testJsVerbose else testJsQuiet + + fun checkExpectedOutputSize(testFileContent: String, testDir: File) { + val expectedSizes = + InTextDirectivesUtils.findListWithPrefixes(testFileContent, "// WASM_DCE_EXPECTED_OUTPUT_SIZE: ") + .map { + val i = it.indexOf(' ') + val extension = it.substring(0, i) + val size = it.substring(i + 1) + extension.trim().lowercase() to size.filter(Char::isDigit).toInt() + } + + val filesByExtension = testDir.listFiles()?.groupBy { it.extension }.orEmpty() + + val errors = expectedSizes.mapNotNull { (extension, expectedSize) -> + val totalSize = filesByExtension[extension].orEmpty().sumOf { it.length() } + + val thresholdPercent = 1 + val thresholdInBytes = expectedSize * thresholdPercent / 100 + + val expectedMinSize = expectedSize - thresholdInBytes + val expectedMaxSize = expectedSize + thresholdInBytes + + val diff = totalSize - expectedSize + + val message = "Total size of $extension files is $totalSize," + + " but expected $expectedSize ∓ $thresholdInBytes [$expectedMinSize .. $expectedMaxSize]." + + " Diff: $diff (${diff * 100 / expectedSize}%)" + + if (debugMode >= DebugMode.DEBUG) { + println(" ------ $message") + } + + if (totalSize !in expectedMinSize..expectedMaxSize) message else null + } + + if (errors.isNotEmpty()) throw AssertionError(errors.joinToString("\n")) + } + + fun writeToFilesAndRunTest(mode: String, res: WasmCompilerResult) { + val dir = File(outputDirBase, mode) + dir.mkdirs() + + writeCompilationResult(res, dir, baseFileName) + File(dir, "test.mjs").writeText(testJs) + + for (mjsFile: AdditionalFile in mjsFiles) { + File(dir, mjsFile.name).writeText(mjsFile.content) + } + + val jsFilePaths = mutableListOf() + for (jsFile: AdditionalFile in jsFiles) { + val file = File(dir, jsFile.name) + file.writeText(jsFile.content) + jsFilePaths += file.canonicalPath + } + + if (debugMode >= DebugMode.DEBUG) { + File(dir, "index.html").writeText( + """ + + + + UNKNOWN + + + + """.trimIndent() + ) + + val path = dir.absolutePath + println(" ------ $mode Wat file://$path/index.wat") + println(" ------ $mode Wasm file://$path/index.wasm") + println(" ------ $mode JS file://$path/index.uninstantiated.mjs") + println(" ------ $mode JS file://$path/index.mjs") + println(" ------ $mode Test file://$path/test.mjs") + val projectName = "kotlin" + println(" ------ $mode HTML http://0.0.0.0:63342/$projectName/${dir.path}/index.html") + for (mjsFile: AdditionalFile in mjsFiles) { + println(" ------ $mode External ESM file://$path/${mjsFile.name}") + } + } + + val testFileText = originalFile.readText() + val failsIn: List = InTextDirectivesUtils.findListWithPrefixes(testFileText, "// WASM_FAILS_IN: ") + + val exceptions = listOf(WasmVM.V8, WasmVM.SpiderMonkey).mapNotNull map@{ vm -> + try { + if (debugMode >= DebugMode.DEBUG) { + println(" ------ Run in ${vm.name}" + if (vm.shortName in failsIn) " (expected to fail)" else "") + } + vm.run( + "./${entryMjs}", + jsFilePaths, + workingDirectory = dir + ) + if (vm.shortName in failsIn) { + return@map AssertionError("The test expected to fail in ${vm.name}. Please update the testdata.") + } + } catch (e: Throwable) { + if (vm.shortName !in failsIn) { + return@map e + } + } + null + } + + when (exceptions.size) { + 0 -> {} // Everything OK + 1 -> { + throw exceptions.single() + } + else -> { + throw AssertionError("Failed with several exceptions. Look at suppressed exceptions below.").apply { + exceptions.forEach { addSuppressed(it) } + } + } + } + + if (mode == "dce") { + checkExpectedOutputSize(testFileText, dir) + } + } + + writeToFilesAndRunTest("dev", artifacts.compilerResult) + writeToFilesAndRunTest("dce", artifacts.compilerResultWithDCE) + } + + private class AdditionalFile(val name: String, val content: String) +} + +fun TestServices.getWasmTestOutputDirectory(): File { + val originalFile = moduleStructure.originalTestDataFiles.first() + val allDirectives = moduleStructure.allDirectives + + val pathToRootOutputDir = allDirectives[WasmEnvironmentConfigurationDirectives.PATH_TO_ROOT_OUTPUT_DIR].first() + val testGroupDirPrefix = allDirectives[WasmEnvironmentConfigurationDirectives.TEST_GROUP_OUTPUT_DIR_PREFIX].first() + val pathToTestDir = allDirectives[WasmEnvironmentConfigurationDirectives.PATH_TO_TEST_DIR].first() + + val testGroupOutputDir = File(File(pathToRootOutputDir, "out"), testGroupDirPrefix) + val stopFile = File(pathToTestDir) + return generateSequence(originalFile.parentFile) { it.parentFile } + .takeWhile { it != stopFile } + .map { it.name } + .toList().asReversed() + .fold(testGroupOutputDir, ::File) + .let { File(it, originalFile.nameWithoutExtension) } +} \ No newline at end of file diff --git a/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/IrCodegenBoxInlineWasmTestGenerated.java b/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/FirWasmCodegenBoxInlineTestGenerated.java similarity index 88% rename from wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/IrCodegenBoxInlineWasmTestGenerated.java rename to wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/FirWasmCodegenBoxInlineTestGenerated.java index 29b8707e353..25ef7377b86 100644 --- a/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/IrCodegenBoxInlineWasmTestGenerated.java +++ b/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/FirWasmCodegenBoxInlineTestGenerated.java @@ -6,12 +6,11 @@ package org.jetbrains.kotlin.wasm.test; import com.intellij.testFramework.TestDataPath; -import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; -import org.jetbrains.kotlin.test.KotlinTestUtils; import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; import java.io.File; import java.util.regex.Pattern; @@ -20,593 +19,661 @@ import java.util.regex.Pattern; @SuppressWarnings("all") @TestMetadata("compiler/testData/codegen/boxInline") @TestDataPath("$PROJECT_ROOT") -@RunWith(JUnit3RunnerWithInners.class) -public class IrCodegenBoxInlineWasmTestGenerated extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - +public class FirWasmCodegenBoxInlineTestGenerated extends AbstractFirWasmCodegenBoxInlineTest { + @Test public void testAllFilesPresentInBoxInline() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/annotations") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Annotations extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Annotations { + @Test public void testAllFilesPresentInAnnotations() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("annotationInstanceInlining.kt") public void testAnnotationInstanceInlining() throws Exception { runTest("compiler/testData/codegen/boxInline/annotations/annotationInstanceInlining.kt"); } + @Test @TestMetadata("instanceInAnonymousClass.kt") public void testInstanceInAnonymousClass() throws Exception { runTest("compiler/testData/codegen/boxInline/annotations/instanceInAnonymousClass.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class AnonymousObject extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class AnonymousObject { + @Test public void testAllFilesPresentInAnonymousObject() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("anonymousObjectInCallChildren.kt") public void testAnonymousObjectInCallChildren() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectInCallChildren.kt"); } + @Test @TestMetadata("anonymousObjectInDefault.kt") public void testAnonymousObjectInDefault() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectInDefault.kt"); } + @Test @TestMetadata("anonymousObjectOnCallSite.kt") public void testAnonymousObjectOnCallSite() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectOnCallSite.kt"); } + @Test @TestMetadata("anonymousObjectOnCallSiteSuperParams.kt") public void testAnonymousObjectOnCallSiteSuperParams() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectOnCallSiteSuperParams.kt"); } + @Test @TestMetadata("anonymousObjectOnDeclarationSite.kt") public void testAnonymousObjectOnDeclarationSite() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectOnDeclarationSite.kt"); } + @Test @TestMetadata("anonymousObjectOnDeclarationSiteSuperParams.kt") public void testAnonymousObjectOnDeclarationSiteSuperParams() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectOnDeclarationSiteSuperParams.kt"); } + @Test @TestMetadata("capturedLambdaInInline.kt") public void testCapturedLambdaInInline() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/capturedLambdaInInline.kt"); } + @Test @TestMetadata("capturedLambdaInInline2.kt") public void testCapturedLambdaInInline2() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/capturedLambdaInInline2.kt"); } + @Test @TestMetadata("capturedLambdaInInline3.kt") public void testCapturedLambdaInInline3() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/capturedLambdaInInline3.kt"); } + @Test @TestMetadata("capturedLambdaInInlineObject.kt") public void testCapturedLambdaInInlineObject() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/capturedLambdaInInlineObject.kt"); } + @Test @TestMetadata("capturedLocalFun.kt") public void testCapturedLocalFun() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/capturedLocalFun.kt"); } + @Test @TestMetadata("capturedLocalFunRef.kt") public void testCapturedLocalFunRef() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/capturedLocalFunRef.kt"); } + @Test @TestMetadata("changingReturnType.kt") public void testChangingReturnType() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/changingReturnType.kt"); } + @Test @TestMetadata("constructOriginalInRegenerated.kt") public void testConstructOriginalInRegenerated() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/constructOriginalInRegenerated.kt"); } + @Test @TestMetadata("constructorVisibility.kt") public void testConstructorVisibility() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/constructorVisibility.kt"); } + @Test @TestMetadata("constructorVisibilityInConstLambda.kt") public void testConstructorVisibilityInConstLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/constructorVisibilityInConstLambda.kt"); } + @Test @TestMetadata("constructorVisibilityInLambda.kt") public void testConstructorVisibilityInLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/constructorVisibilityInLambda.kt"); } + @Test @TestMetadata("defineClass.kt") public void testDefineClass() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/defineClass.kt"); } + @Test @TestMetadata("fakeOverrideInDefaultMultiModule.kt") public void testFakeOverrideInDefaultMultiModule() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/fakeOverrideInDefaultMultiModule.kt"); } + @Test @TestMetadata("fakeOverrideMultiModule.kt") public void testFakeOverrideMultiModule() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/fakeOverrideMultiModule.kt"); } + @Test @TestMetadata("functionExpression.kt") public void testFunctionExpression() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/functionExpression.kt"); } + @Test @TestMetadata("inlineCallInsideInlineLambda.kt") public void testInlineCallInsideInlineLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/inlineCallInsideInlineLambda.kt"); } + @Test @TestMetadata("kt13182.kt") public void testKt13182() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt13182.kt"); } + @Test @TestMetadata("kt13374.kt") public void testKt13374() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt13374.kt"); } + @Test @TestMetadata("kt14011.kt") public void testKt14011() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt14011.kt"); } + @Test @TestMetadata("kt14011_2.kt") public void testKt14011_2() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt14011_2.kt"); } + @Test @TestMetadata("kt14011_3.kt") public void testKt14011_3() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt14011_3.kt"); } + @Test @TestMetadata("kt15751.kt") public void testKt15751() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt15751.kt"); } + @Test @TestMetadata("kt17972.kt") public void testKt17972() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972.kt"); } + @Test @TestMetadata("kt17972_2.kt") public void testKt17972_2() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_2.kt"); } + @Test @TestMetadata("kt17972_3.kt") public void testKt17972_3() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_3.kt"); } + @Test @TestMetadata("kt17972_4.kt") public void testKt17972_4() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_4.kt"); } + @Test @TestMetadata("kt17972_5.kt") public void testKt17972_5() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_5.kt"); } + @Test @TestMetadata("kt17972_super.kt") public void testKt17972_super() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_super.kt"); } + @Test @TestMetadata("kt17972_super2.kt") public void testKt17972_super2() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_super2.kt"); } + @Test @TestMetadata("kt17972_super3.kt") public void testKt17972_super3() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_super3.kt"); } + @Test @TestMetadata("kt19389.kt") public void testKt19389() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt19389.kt"); } + @Test @TestMetadata("kt19399.kt") public void testKt19399() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt19399.kt"); } + @Test @TestMetadata("kt19723.kt") public void testKt19723() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt19723.kt"); } + @Test @TestMetadata("kt34656.kt") public void testKt34656() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt34656.kt"); } + @Test @TestMetadata("kt38197.kt") public void testKt38197() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt38197.kt"); } + @Test @TestMetadata("kt42815.kt") public void testKt42815() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt42815.kt"); } + @Test @TestMetadata("kt42815_delegated.kt") public void testKt42815_delegated() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt42815_delegated.kt"); } + @Test @TestMetadata("kt51950.kt") public void testKt51950() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt51950.kt"); } + @Test @TestMetadata("kt52795.kt") public void testKt52795() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt52795.kt"); } + @Test @TestMetadata("kt52795_2.kt") public void testKt52795_2() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt52795_2.kt"); } + @Test @TestMetadata("kt52795_3.kt") public void testKt52795_3() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt52795_3.kt"); } + @Test @TestMetadata("kt52795_4.kt") public void testKt52795_4() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt52795_4.kt"); } + @Test @TestMetadata("kt52795_5.kt") public void testKt52795_5() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt52795_5.kt"); } + @Test @TestMetadata("kt57053.kt") public void testKt57053() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt57053.kt"); } + @Test @TestMetadata("kt6007.kt") public void testKt6007() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt6007.kt"); } + @Test @TestMetadata("kt6552.kt") public void testKt6552() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt6552.kt"); } + @Test @TestMetadata("kt8133.kt") public void testKt8133() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt8133.kt"); } + @Test @TestMetadata("kt9064.kt") public void testKt9064() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt9064.kt"); } + @Test @TestMetadata("kt9064v2.kt") public void testKt9064v2() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt9064v2.kt"); } + @Test @TestMetadata("kt9591.kt") public void testKt9591() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt9591.kt"); } + @Test @TestMetadata("kt9877.kt") public void testKt9877() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt9877.kt"); } + @Test @TestMetadata("kt9877_2.kt") public void testKt9877_2() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/kt9877_2.kt"); } + @Test @TestMetadata("objectInLambdaCapturesAnotherObject.kt") public void testObjectInLambdaCapturesAnotherObject() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/objectInLambdaCapturesAnotherObject.kt"); } + @Test @TestMetadata("safeCall.kt") public void testSafeCall() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/safeCall.kt"); } + @Test @TestMetadata("safeCall_2.kt") public void testSafeCall_2() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/safeCall_2.kt"); } + @Test @TestMetadata("sharedFromCrossinline.kt") public void testSharedFromCrossinline() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/sharedFromCrossinline.kt"); } + @Test @TestMetadata("superConstructorWithObjectParameter.kt") public void testSuperConstructorWithObjectParameter() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/superConstructorWithObjectParameter.kt"); } + @Test @TestMetadata("typeInfo.kt") public void testTypeInfo() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/typeInfo.kt"); } + @Test @TestMetadata("withInlineMethod.kt") public void testWithInlineMethod() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/withInlineMethod.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject/enumEntries") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class EnumEntries extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class EnumEntries { + @Test public void testAllFilesPresentInEnumEntries() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumEntries"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject/enumWhen") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class EnumWhen extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class EnumWhen { + @Test public void testAllFilesPresentInEnumWhen() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumWhen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("callSite.kt") public void testCallSite() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/enumWhen/callSite.kt"); } + @Test @TestMetadata("declSite.kt") public void testDeclSite() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/enumWhen/declSite.kt"); } + @Test @TestMetadata("declSiteSeveralMappings.kt") public void testDeclSiteSeveralMappings() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/enumWhen/declSiteSeveralMappings.kt"); } + @Test @TestMetadata("declSiteSeveralMappingsDifOrder.kt") public void testDeclSiteSeveralMappingsDifOrder() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/enumWhen/declSiteSeveralMappingsDifOrder.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ProperRecapturing extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ProperRecapturing { + @Test public void testAllFilesPresentInProperRecapturing() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("inlineChain.kt") public void testInlineChain() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing/inlineChain.kt"); } + @Test @TestMetadata("lambdaChain.kt") public void testLambdaChain() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing/lambdaChain.kt"); } + @Test @TestMetadata("lambdaChainSimple.kt") public void testLambdaChainSimple() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing/lambdaChainSimple.kt"); } + @Test @TestMetadata("lambdaChain_2.kt") public void testLambdaChain_2() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing/lambdaChain_2.kt"); } + @Test @TestMetadata("lambdaChain_3.kt") public void testLambdaChain_3() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing/lambdaChain_3.kt"); } + @Test @TestMetadata("noInlineLambda.kt") public void testNoInlineLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing/noInlineLambda.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ProperRecapturingInClass extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ProperRecapturingInClass { + @Test public void testAllFilesPresentInProperRecapturingInClass() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("inlineChain.kt") public void testInlineChain() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/inlineChain.kt"); } + @Test @TestMetadata("inlinelambdaChain.kt") public void testInlinelambdaChain() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/inlinelambdaChain.kt"); } + @Test @TestMetadata("lambdaChain.kt") public void testLambdaChain() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/lambdaChain.kt"); } + @Test @TestMetadata("lambdaChainSimple.kt") public void testLambdaChainSimple() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/lambdaChainSimple.kt"); } + @Test @TestMetadata("lambdaChainSimple_2.kt") public void testLambdaChainSimple_2() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/lambdaChainSimple_2.kt"); } + @Test @TestMetadata("lambdaChain_2.kt") public void testLambdaChain_2() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/lambdaChain_2.kt"); } + @Test @TestMetadata("lambdaChain_3.kt") public void testLambdaChain_3() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/lambdaChain_3.kt"); } + @Test @TestMetadata("noCapturedThisOnCallSite.kt") public void testNoCapturedThisOnCallSite() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/noCapturedThisOnCallSite.kt"); } + @Test @TestMetadata("noInlineLambda.kt") public void testNoInlineLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/noInlineLambda.kt"); } + @Test @TestMetadata("twoInlineLambda.kt") public void testTwoInlineLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/twoInlineLambda.kt"); } + @Test @TestMetadata("twoInlineLambdaComplex.kt") public void testTwoInlineLambdaComplex() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/twoInlineLambdaComplex.kt"); } + @Test @TestMetadata("twoInlineLambdaComplex_2.kt") public void testTwoInlineLambdaComplex_2() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/twoInlineLambdaComplex_2.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject/sam") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Sam extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Sam { + @Test public void testAllFilesPresentInSam() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TwoCapturedReceivers extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class TwoCapturedReceivers { + @Test public void testAllFilesPresentInTwoCapturedReceivers() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt8668.kt") public void testKt8668() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers/kt8668.kt"); } + @Test @TestMetadata("kt8668_2.kt") public void testKt8668_2() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers/kt8668_2.kt"); } + @Test @TestMetadata("kt8668_3.kt") public void testKt8668_3() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers/kt8668_3.kt"); } + @Test @TestMetadata("kt8668_nested.kt") public void testKt8668_nested() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers/kt8668_nested.kt"); } + @Test @TestMetadata("kt8668_nested_2.kt") public void testKt8668_nested_2() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers/kt8668_nested_2.kt"); } + @Test @TestMetadata("twoDifferentDispatchReceivers.kt") public void testTwoDifferentDispatchReceivers() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers/twoDifferentDispatchReceivers.kt"); } + @Test @TestMetadata("twoExtensionReceivers.kt") public void testTwoExtensionReceivers() throws Exception { runTest("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers/twoExtensionReceivers.kt"); @@ -614,443 +681,487 @@ public class IrCodegenBoxInlineWasmTestGenerated extends AbstractIrCodegenBoxInl } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/argumentOrder") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ArgumentOrder extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ArgumentOrder { + @Test public void testAllFilesPresentInArgumentOrder() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("boundFunctionReference.kt") public void testBoundFunctionReference() throws Exception { runTest("compiler/testData/codegen/boxInline/argumentOrder/boundFunctionReference.kt"); } + @Test @TestMetadata("boundFunctionReference2.kt") public void testBoundFunctionReference2() throws Exception { runTest("compiler/testData/codegen/boxInline/argumentOrder/boundFunctionReference2.kt"); } + @Test @TestMetadata("captured.kt") public void testCaptured() throws Exception { runTest("compiler/testData/codegen/boxInline/argumentOrder/captured.kt"); } + @Test @TestMetadata("capturedInExtension.kt") public void testCapturedInExtension() throws Exception { runTest("compiler/testData/codegen/boxInline/argumentOrder/capturedInExtension.kt"); } + @Test @TestMetadata("defaultParametersAndLastVararg.kt") public void testDefaultParametersAndLastVararg() throws Exception { runTest("compiler/testData/codegen/boxInline/argumentOrder/defaultParametersAndLastVararg.kt"); } + @Test @TestMetadata("defaultParametersAndLastVarargWithCorrectOrder.kt") public void testDefaultParametersAndLastVarargWithCorrectOrder() throws Exception { runTest("compiler/testData/codegen/boxInline/argumentOrder/defaultParametersAndLastVarargWithCorrectOrder.kt"); } + @Test @TestMetadata("extension.kt") public void testExtension() throws Exception { runTest("compiler/testData/codegen/boxInline/argumentOrder/extension.kt"); } + @Test @TestMetadata("extensionInClass.kt") public void testExtensionInClass() throws Exception { runTest("compiler/testData/codegen/boxInline/argumentOrder/extensionInClass.kt"); } + @Test @TestMetadata("lambdaMigration.kt") public void testLambdaMigration() throws Exception { runTest("compiler/testData/codegen/boxInline/argumentOrder/lambdaMigration.kt"); } + @Test @TestMetadata("lambdaMigrationInClass.kt") public void testLambdaMigrationInClass() throws Exception { runTest("compiler/testData/codegen/boxInline/argumentOrder/lambdaMigrationInClass.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/boxInline/argumentOrder/simple.kt"); } + @Test @TestMetadata("simpleInClass.kt") public void testSimpleInClass() throws Exception { runTest("compiler/testData/codegen/boxInline/argumentOrder/simpleInClass.kt"); } + @Test @TestMetadata("varargAndDefaultParameters.kt") public void testVarargAndDefaultParameters() throws Exception { runTest("compiler/testData/codegen/boxInline/argumentOrder/varargAndDefaultParameters.kt"); } + @Test @TestMetadata("varargAndDefaultParametersWithCorrectOrder.kt") public void testVarargAndDefaultParametersWithCorrectOrder() throws Exception { runTest("compiler/testData/codegen/boxInline/argumentOrder/varargAndDefaultParametersWithCorrectOrder.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/arrayConvention") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ArrayConvention extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ArrayConvention { + @Test public void testAllFilesPresentInArrayConvention() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/arrayConvention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("simpleAccess.kt") public void testSimpleAccess() throws Exception { runTest("compiler/testData/codegen/boxInline/arrayConvention/simpleAccess.kt"); } + @Test @TestMetadata("simpleAccessInClass.kt") public void testSimpleAccessInClass() throws Exception { runTest("compiler/testData/codegen/boxInline/arrayConvention/simpleAccessInClass.kt"); } + @Test @TestMetadata("simpleAccessWithDefault.kt") public void testSimpleAccessWithDefault() throws Exception { runTest("compiler/testData/codegen/boxInline/arrayConvention/simpleAccessWithDefault.kt"); } + @Test @TestMetadata("simpleAccessWithDefaultInClass.kt") public void testSimpleAccessWithDefaultInClass() throws Exception { runTest("compiler/testData/codegen/boxInline/arrayConvention/simpleAccessWithDefaultInClass.kt"); } + @Test @TestMetadata("simpleAccessWithLambda.kt") public void testSimpleAccessWithLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/arrayConvention/simpleAccessWithLambda.kt"); } + @Test @TestMetadata("simpleAccessWithLambdaInClass.kt") public void testSimpleAccessWithLambdaInClass() throws Exception { runTest("compiler/testData/codegen/boxInline/arrayConvention/simpleAccessWithLambdaInClass.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/assert") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Assert extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Assert { + @Test public void testAllFilesPresentInAssert() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/builders") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Builders extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Builders { + @Test public void testAllFilesPresentInBuilders() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/builders"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/bytecodePreprocessing") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class BytecodePreprocessing extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class BytecodePreprocessing { + @Test public void testAllFilesPresentInBytecodePreprocessing() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/bytecodePreprocessing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/callableReference") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class CallableReference extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class CallableReference { + @Test @TestMetadata("adapted.kt") public void testAdapted() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/adapted.kt"); } + @Test public void testAllFilesPresentInCallableReference() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("classLevel.kt") public void testClassLevel() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/classLevel.kt"); } + @Test @TestMetadata("classLevel2.kt") public void testClassLevel2() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/classLevel2.kt"); } + @Test @TestMetadata("constructor.kt") public void testConstructor() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/constructor.kt"); } + @Test @TestMetadata("inlineCallableReference.kt") public void testInlineCallableReference() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/inlineCallableReference.kt"); } + @Test @TestMetadata("innerGenericConstuctor.kt") public void testInnerGenericConstuctor() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/innerGenericConstuctor.kt"); } + @Test @TestMetadata("intrinsic.kt") public void testIntrinsic() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/intrinsic.kt"); } + @Test @TestMetadata("kt15449.kt") public void testKt15449() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/kt15449.kt"); } + @Test @TestMetadata("kt15751_2.kt") public void testKt15751_2() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/kt15751_2.kt"); } + @Test @TestMetadata("kt16411.kt") public void testKt16411() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/kt16411.kt"); } + @Test @TestMetadata("kt35101.kt") public void testKt35101() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/kt35101.kt"); } + @Test @TestMetadata("propertyIntrinsic.kt") public void testPropertyIntrinsic() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/propertyIntrinsic.kt"); } + @Test @TestMetadata("propertyReference.kt") public void testPropertyReference() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/propertyReference.kt"); } + @Test @TestMetadata("topLevel.kt") public void testTopLevel() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/topLevel.kt"); } + @Test @TestMetadata("topLevelExtension.kt") public void testTopLevelExtension() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/topLevelExtension.kt"); } + @Test @TestMetadata("topLevelProperty.kt") public void testTopLevelProperty() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/topLevelProperty.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/callableReference/adaptedReferences") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class AdaptedReferences extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class AdaptedReferences { + @Test public void testAllFilesPresentInAdaptedReferences() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/adaptedReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("inlineBound.kt") public void testInlineBound() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/adaptedReferences/inlineBound.kt"); } + @Test @TestMetadata("inlineDefault.kt") public void testInlineDefault() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/adaptedReferences/inlineDefault.kt"); } + @Test @TestMetadata("inlineVararg.kt") public void testInlineVararg() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/adaptedReferences/inlineVararg.kt"); } + @Test @TestMetadata("inlineVarargAndDefault.kt") public void testInlineVarargAndDefault() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/adaptedReferences/inlineVarargAndDefault.kt"); } + @Test @TestMetadata("inlineVarargInts.kt") public void testInlineVarargInts() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/adaptedReferences/inlineVarargInts.kt"); } + @Test @TestMetadata("multipleCallableReferenceUsage.kt") public void testMultipleCallableReferenceUsage() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/adaptedReferences/multipleCallableReferenceUsage.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/callableReference/bound") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Bound extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Bound { + @Test public void testAllFilesPresentInBound() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("classProperty.kt") public void testClassProperty() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/classProperty.kt"); } + @Test @TestMetadata("doubleBoundToThis.kt") public void testDoubleBoundToThis() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/doubleBoundToThis.kt"); } + @Test @TestMetadata("emptyLhsFunction.kt") public void testEmptyLhsFunction() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/emptyLhsFunction.kt"); } + @Test @TestMetadata("emptyLhsOnInlineProperty.kt") public void testEmptyLhsOnInlineProperty() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/emptyLhsOnInlineProperty.kt"); } + @Test @TestMetadata("emptyLhsProperty.kt") public void testEmptyLhsProperty() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/emptyLhsProperty.kt"); } + @Test @TestMetadata("expression.kt") public void testExpression() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/expression.kt"); } + @Test @TestMetadata("extensionReceiver.kt") public void testExtensionReceiver() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/extensionReceiver.kt"); } + @Test @TestMetadata("filter.kt") public void testFilter() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/filter.kt"); } + @Test @TestMetadata("inlineValueParameterInsteadOfReceiver.kt") public void testInlineValueParameterInsteadOfReceiver() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/inlineValueParameterInsteadOfReceiver.kt"); } + @Test @TestMetadata("innerGenericConstuctor.kt") public void testInnerGenericConstuctor() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/innerGenericConstuctor.kt"); } + @Test @TestMetadata("intrinsic.kt") public void testIntrinsic() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/intrinsic.kt"); } + @Test @TestMetadata("kt18728.kt") public void testKt18728() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/kt18728.kt"); } + @Test @TestMetadata("kt18728_2.kt") public void testKt18728_2() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/kt18728_2.kt"); } + @Test @TestMetadata("kt18728_3.kt") public void testKt18728_3() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/kt18728_3.kt"); } + @Test @TestMetadata("kt18728_4.kt") public void testKt18728_4() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/kt18728_4.kt"); } + @Test @TestMetadata("kt30933.kt") public void testKt30933() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/kt30933.kt"); } + @Test @TestMetadata("lambdaOnLhs.kt") public void testLambdaOnLhs() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/lambdaOnLhs.kt"); } + @Test @TestMetadata("map.kt") public void testMap() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/map.kt"); } + @Test @TestMetadata("mixed.kt") public void testMixed() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/mixed.kt"); } + @Test @TestMetadata("objectProperty.kt") public void testObjectProperty() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/objectProperty.kt"); } + @Test @TestMetadata("propertyImportedFromObject.kt") public void testPropertyImportedFromObject() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/propertyImportedFromObject.kt"); } + @Test @TestMetadata("sideEffect.kt") public void testSideEffect() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/sideEffect.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/simple.kt"); } + @Test @TestMetadata("simpleVal.kt") public void testSimpleVal() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/simpleVal.kt"); } + @Test @TestMetadata("simpleVal2.kt") public void testSimpleVal2() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/simpleVal2.kt"); } + @Test @TestMetadata("topLevelExtensionProperty.kt") public void testTopLevelExtensionProperty() throws Exception { runTest("compiler/testData/codegen/boxInline/callableReference/bound/topLevelExtensionProperty.kt"); @@ -1058,699 +1169,800 @@ public class IrCodegenBoxInlineWasmTestGenerated extends AbstractIrCodegenBoxInl } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/capture") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Capture extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Capture { + @Test public void testAllFilesPresentInCapture() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/capture"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("captureInlinable.kt") public void testCaptureInlinable() throws Exception { runTest("compiler/testData/codegen/boxInline/capture/captureInlinable.kt"); } + @Test @TestMetadata("captureInlinableAndOther.kt") public void testCaptureInlinableAndOther() throws Exception { runTest("compiler/testData/codegen/boxInline/capture/captureInlinableAndOther.kt"); } + @Test @TestMetadata("captureThisAndReceiver.kt") public void testCaptureThisAndReceiver() throws Exception { runTest("compiler/testData/codegen/boxInline/capture/captureThisAndReceiver.kt"); } + @Test @TestMetadata("generics.kt") public void testGenerics() throws Exception { runTest("compiler/testData/codegen/boxInline/capture/generics.kt"); } + @Test @TestMetadata("kt48230.kt") public void testKt48230() throws Exception { runTest("compiler/testData/codegen/boxInline/capture/kt48230.kt"); } + @Test @TestMetadata("kt48230_2.kt") public void testKt48230_2() throws Exception { runTest("compiler/testData/codegen/boxInline/capture/kt48230_2.kt"); } + @Test @TestMetadata("kt56500.kt") public void testKt56500() throws Exception { runTest("compiler/testData/codegen/boxInline/capture/kt56500.kt"); } + @Test @TestMetadata("kt56965.kt") public void testKt56965() throws Exception { runTest("compiler/testData/codegen/boxInline/capture/kt56965.kt"); } + @Test @TestMetadata("kt56965_2.kt") public void testKt56965_2() throws Exception { runTest("compiler/testData/codegen/boxInline/capture/kt56965_2.kt"); } + @Test @TestMetadata("simpleCapturingInClass.kt") public void testSimpleCapturingInClass() throws Exception { runTest("compiler/testData/codegen/boxInline/capture/simpleCapturingInClass.kt"); } + @Test @TestMetadata("simpleCapturingInPackage.kt") public void testSimpleCapturingInPackage() throws Exception { runTest("compiler/testData/codegen/boxInline/capture/simpleCapturingInPackage.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/complex") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Complex extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Complex { + @Test public void testAllFilesPresentInComplex() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("closureChain.kt") public void testClosureChain() throws Exception { runTest("compiler/testData/codegen/boxInline/complex/closureChain.kt"); } + @Test @TestMetadata("kt44429.kt") public void testKt44429() throws Exception { runTest("compiler/testData/codegen/boxInline/complex/kt44429.kt"); } + @Test @TestMetadata("swapAndWith.kt") public void testSwapAndWith() throws Exception { runTest("compiler/testData/codegen/boxInline/complex/swapAndWith.kt"); } + @Test @TestMetadata("swapAndWith2.kt") public void testSwapAndWith2() throws Exception { runTest("compiler/testData/codegen/boxInline/complex/swapAndWith2.kt"); } + @Test @TestMetadata("use.kt") public void testUse() throws Exception { runTest("compiler/testData/codegen/boxInline/complex/use.kt"); } + @Test @TestMetadata("with.kt") public void testWith() throws Exception { runTest("compiler/testData/codegen/boxInline/complex/with.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/complexStack") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ComplexStack extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ComplexStack { + @Test public void testAllFilesPresentInComplexStack() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complexStack"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("asCheck.kt") public void testAsCheck() throws Exception { runTest("compiler/testData/codegen/boxInline/complexStack/asCheck.kt"); } + @Test @TestMetadata("asCheck2.kt") public void testAsCheck2() throws Exception { runTest("compiler/testData/codegen/boxInline/complexStack/asCheck2.kt"); } + @Test @TestMetadata("breakContinueInInlineLambdaArgument.kt") public void testBreakContinueInInlineLambdaArgument() throws Exception { runTest("compiler/testData/codegen/boxInline/complexStack/breakContinueInInlineLambdaArgument.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/boxInline/complexStack/simple.kt"); } + @Test @TestMetadata("simple2.kt") public void testSimple2() throws Exception { runTest("compiler/testData/codegen/boxInline/complexStack/simple2.kt"); } + @Test @TestMetadata("simple3.kt") public void testSimple3() throws Exception { runTest("compiler/testData/codegen/boxInline/complexStack/simple3.kt"); } + @Test @TestMetadata("simple4.kt") public void testSimple4() throws Exception { runTest("compiler/testData/codegen/boxInline/complexStack/simple4.kt"); } + @Test @TestMetadata("simpleExtension.kt") public void testSimpleExtension() throws Exception { runTest("compiler/testData/codegen/boxInline/complexStack/simpleExtension.kt"); } + @Test @TestMetadata("spillConstructorArgumentsAndInlineLambdaParameter.kt") public void testSpillConstructorArgumentsAndInlineLambdaParameter() throws Exception { runTest("compiler/testData/codegen/boxInline/complexStack/spillConstructorArgumentsAndInlineLambdaParameter.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/contracts") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Contracts extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Contracts { + @Test public void testAllFilesPresentInContracts() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("cfgDependendValInitialization.kt") public void testCfgDependendValInitialization() throws Exception { runTest("compiler/testData/codegen/boxInline/contracts/cfgDependendValInitialization.kt"); } + @Test @TestMetadata("complexInitializer.kt") public void testComplexInitializer() throws Exception { runTest("compiler/testData/codegen/boxInline/contracts/complexInitializer.kt"); } + @Test @TestMetadata("complexInitializerWithStackTransformation.kt") public void testComplexInitializerWithStackTransformation() throws Exception { runTest("compiler/testData/codegen/boxInline/contracts/complexInitializerWithStackTransformation.kt"); } + @Test @TestMetadata("crossinlineCallableReference.kt") public void testCrossinlineCallableReference() throws Exception { runTest("compiler/testData/codegen/boxInline/contracts/crossinlineCallableReference.kt"); } + @Test @TestMetadata("definiteLongValInitialization.kt") public void testDefiniteLongValInitialization() throws Exception { runTest("compiler/testData/codegen/boxInline/contracts/definiteLongValInitialization.kt"); } + @Test @TestMetadata("definiteNestedValInitialization.kt") public void testDefiniteNestedValInitialization() throws Exception { runTest("compiler/testData/codegen/boxInline/contracts/definiteNestedValInitialization.kt"); } + @Test @TestMetadata("definiteValInitInInitializer.kt") public void testDefiniteValInitInInitializer() throws Exception { runTest("compiler/testData/codegen/boxInline/contracts/definiteValInitInInitializer.kt"); } + @Test @TestMetadata("definiteValInitialization.kt") public void testDefiniteValInitialization() throws Exception { runTest("compiler/testData/codegen/boxInline/contracts/definiteValInitialization.kt"); } + @Test @TestMetadata("exactlyOnceCrossinline.kt") public void testExactlyOnceCrossinline() throws Exception { runTest("compiler/testData/codegen/boxInline/contracts/exactlyOnceCrossinline.kt"); } + @Test @TestMetadata("exactlyOnceCrossinline2.kt") public void testExactlyOnceCrossinline2() throws Exception { runTest("compiler/testData/codegen/boxInline/contracts/exactlyOnceCrossinline2.kt"); } + @Test @TestMetadata("exactlyOnceNoinline.kt") public void testExactlyOnceNoinline() throws Exception { runTest("compiler/testData/codegen/boxInline/contracts/exactlyOnceNoinline.kt"); } + @Test @TestMetadata("nonLocalReturn.kt") public void testNonLocalReturn() throws Exception { runTest("compiler/testData/codegen/boxInline/contracts/nonLocalReturn.kt"); } + @Test @TestMetadata("nonLocalReturnWithCycle.kt") public void testNonLocalReturnWithCycle() throws Exception { runTest("compiler/testData/codegen/boxInline/contracts/nonLocalReturnWithCycle.kt"); } + @Test @TestMetadata("propertyInitialization.kt") public void testPropertyInitialization() throws Exception { runTest("compiler/testData/codegen/boxInline/contracts/propertyInitialization.kt"); } + @Test @TestMetadata("valInitializationAndUsageInNestedLambda.kt") public void testValInitializationAndUsageInNestedLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/contracts/valInitializationAndUsageInNestedLambda.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/defaultValues") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DefaultValues extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DefaultValues { + @Test @TestMetadata("33Parameters.kt") public void test33Parameters() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/33Parameters.kt"); } + @Test @TestMetadata("33ParametersInConstructor.kt") public void test33ParametersInConstructor() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/33ParametersInConstructor.kt"); } + @Test public void testAllFilesPresentInDefaultValues() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("defaultInExtension.kt") public void testDefaultInExtension() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/defaultInExtension.kt"); } + @Test @TestMetadata("defaultMethod.kt") public void testDefaultMethod() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/defaultMethod.kt"); } + @Test @TestMetadata("defaultMethodInClass.kt") public void testDefaultMethodInClass() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/defaultMethodInClass.kt"); } + @Test @TestMetadata("defaultParamRemapping.kt") public void testDefaultParamRemapping() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/defaultParamRemapping.kt"); } + @Test @TestMetadata("inlineInDefaultParameter.kt") public void testInlineInDefaultParameter() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/inlineInDefaultParameter.kt"); } + @Test @TestMetadata("inlineLambdaInNoInlineDefault.kt") public void testInlineLambdaInNoInlineDefault() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/inlineLambdaInNoInlineDefault.kt"); } + @Test @TestMetadata("kt11479.kt") public void testKt11479() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/kt11479.kt"); } + @Test @TestMetadata("kt11479InlinedDefaultParameter.kt") public void testKt11479InlinedDefaultParameter() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/kt11479InlinedDefaultParameter.kt"); } + @Test @TestMetadata("kt14564.kt") public void testKt14564() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/kt14564.kt"); } + @Test @TestMetadata("kt14564_2.kt") public void testKt14564_2() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/kt14564_2.kt"); } + @Test @TestMetadata("kt16496.kt") public void testKt16496() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/kt16496.kt"); } + @Test @TestMetadata("kt18689.kt") public void testKt18689() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/kt18689.kt"); } + @Test @TestMetadata("kt18689_2.kt") public void testKt18689_2() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/kt18689_2.kt"); } + @Test @TestMetadata("kt18689_3.kt") public void testKt18689_3() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/kt18689_3.kt"); } + @Test @TestMetadata("kt18689_4.kt") public void testKt18689_4() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/kt18689_4.kt"); } + @Test @TestMetadata("kt5685.kt") public void testKt5685() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/kt5685.kt"); } + @Test @TestMetadata("simpleDefaultMethod.kt") public void testSimpleDefaultMethod() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/simpleDefaultMethod.kt"); } + @Test @TestMetadata("varArgNoInline.kt") public void testVarArgNoInline() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/varArgNoInline.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class LambdaInlining extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class LambdaInlining { + @Test public void testAllFilesPresentInLambdaInlining() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("checkLambdaClassIsPresent.kt") public void testCheckLambdaClassIsPresent() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/checkLambdaClassIsPresent.kt"); } + @Test @TestMetadata("checkLambdaClassesArePresent.kt") public void testCheckLambdaClassesArePresent() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/checkLambdaClassesArePresent.kt"); } + @Test @TestMetadata("checkObjectClassIsPresent.kt") public void testCheckObjectClassIsPresent() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/checkObjectClassIsPresent.kt"); } + @Test @TestMetadata("checkStaticLambdaClassIsPresent.kt") public void testCheckStaticLambdaClassIsPresent() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/checkStaticLambdaClassIsPresent.kt"); } + @Test @TestMetadata("checkStaticLambdaClassesArePresent.kt") public void testCheckStaticLambdaClassesArePresent() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/checkStaticLambdaClassesArePresent.kt"); } + @Test @TestMetadata("checkStaticObjectClassIsPresent.kt") public void testCheckStaticObjectClassIsPresent() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/checkStaticObjectClassIsPresent.kt"); } + @Test @TestMetadata("defaultAfterCapturing.kt") public void testDefaultAfterCapturing() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/defaultAfterCapturing.kt"); } + @Test @TestMetadata("defaultCallInDefaultLambda.kt") public void testDefaultCallInDefaultLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/defaultCallInDefaultLambda.kt"); } + @Test @TestMetadata("defaultLambdaInNoInline.kt") public void testDefaultLambdaInNoInline() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/defaultLambdaInNoInline.kt"); } + @Test @TestMetadata("differentInvokeSignature.kt") public void testDifferentInvokeSignature() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/differentInvokeSignature.kt"); } + @Test @TestMetadata("genericLambda.kt") public void testGenericLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/genericLambda.kt"); } + @Test @TestMetadata("instanceCapturedInClass.kt") public void testInstanceCapturedInClass() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/instanceCapturedInClass.kt"); } + @Test @TestMetadata("instanceCapturedInInterface.kt") public void testInstanceCapturedInInterface() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/instanceCapturedInInterface.kt"); } + @Test @TestMetadata("kt21827.kt") public void testKt21827() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/kt21827.kt"); } + @Test @TestMetadata("kt21946.kt") public void testKt21946() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/kt21946.kt"); } + @Test @TestMetadata("kt24477.kt") public void testKt24477() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/kt24477.kt"); } + @Test @TestMetadata("kt25106.kt") public void testKt25106() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/kt25106.kt"); } + @Test @TestMetadata("lambdaTakesResult.kt") public void testLambdaTakesResult() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/lambdaTakesResult.kt"); } + @Test @TestMetadata("noInline.kt") public void testNoInline() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/noInline.kt"); } + @Test @TestMetadata("nonDefaultInlineInNoInline.kt") public void testNonDefaultInlineInNoInline() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/nonDefaultInlineInNoInline.kt"); } + @Test @TestMetadata("receiverClash.kt") public void testReceiverClash() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/receiverClash.kt"); } + @Test @TestMetadata("receiverClash2.kt") public void testReceiverClash2() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/receiverClash2.kt"); } + @Test @TestMetadata("receiverClashInClass.kt") public void testReceiverClashInClass() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/receiverClashInClass.kt"); } + @Test @TestMetadata("receiverClashInClass2.kt") public void testReceiverClashInClass2() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/receiverClashInClass2.kt"); } + @Test @TestMetadata("reordering.kt") public void testReordering() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/reordering.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/simple.kt"); } + @Test @TestMetadata("simpleErased.kt") public void testSimpleErased() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/simpleErased.kt"); } + @Test @TestMetadata("simpleErasedStaticInstance.kt") public void testSimpleErasedStaticInstance() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/simpleErasedStaticInstance.kt"); } + @Test @TestMetadata("simpleExtension.kt") public void testSimpleExtension() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/simpleExtension.kt"); } + @Test @TestMetadata("simpleGeneric.kt") public void testSimpleGeneric() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/simpleGeneric.kt"); } + @Test @TestMetadata("simpleStaticInstance.kt") public void testSimpleStaticInstance() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/simpleStaticInstance.kt"); } + @Test @TestMetadata("thisClash.kt") public void testThisClash() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/thisClash.kt"); } + @Test @TestMetadata("thisClashInClass.kt") public void testThisClashInClass() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/thisClashInClass.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class CallableReferences extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class CallableReferences { + @Test public void testAllFilesPresentInCallableReferences() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("boundFunctionReference.kt") public void testBoundFunctionReference() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundFunctionReference.kt"); } + @Test @TestMetadata("boundFunctionReferenceOnInt.kt") public void testBoundFunctionReferenceOnInt() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundFunctionReferenceOnInt.kt"); } + @Test @TestMetadata("boundFunctionReferenceOnLong.kt") public void testBoundFunctionReferenceOnLong() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundFunctionReferenceOnLong.kt"); } + @Test @TestMetadata("boundInlineClassMethod.kt") public void testBoundInlineClassMethod() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundInlineClassMethod.kt"); } + @Test @TestMetadata("boundInlineClassMethodWithAny.kt") public void testBoundInlineClassMethodWithAny() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundInlineClassMethodWithAny.kt"); } + @Test @TestMetadata("boundInlineClassMethodWithInt.kt") public void testBoundInlineClassMethodWithInt() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundInlineClassMethodWithInt.kt"); } + @Test @TestMetadata("boundPropertyReference.kt") public void testBoundPropertyReference() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundPropertyReference.kt"); } + @Test @TestMetadata("boundPropertyReferenceOnInt.kt") public void testBoundPropertyReferenceOnInt() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundPropertyReferenceOnInt.kt"); } + @Test @TestMetadata("boundPropertyReferenceOnLong.kt") public void testBoundPropertyReferenceOnLong() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundPropertyReferenceOnLong.kt"); } + @Test @TestMetadata("constuctorReference.kt") public void testConstuctorReference() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/constuctorReference.kt"); } + @Test @TestMetadata("defaultAfterBoundReference.kt") public void testDefaultAfterBoundReference() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/defaultAfterBoundReference.kt"); } + @Test @TestMetadata("differentInvokeSignature.kt") public void testDifferentInvokeSignature() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/differentInvokeSignature.kt"); } + @Test @TestMetadata("differentInvokeSignature2.kt") public void testDifferentInvokeSignature2() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/differentInvokeSignature2.kt"); } + @Test @TestMetadata("differentInvokeSignature3.kt") public void testDifferentInvokeSignature3() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/differentInvokeSignature3.kt"); } + @Test @TestMetadata("functionImportedFromObject.kt") public void testFunctionImportedFromObject() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/functionImportedFromObject.kt"); } + @Test @TestMetadata("functionReference.kt") public void testFunctionReference() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/functionReference.kt"); } + @Test @TestMetadata("functionReferenceFromClass.kt") public void testFunctionReferenceFromClass() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/functionReferenceFromClass.kt"); } + @Test @TestMetadata("functionReferenceFromObject.kt") public void testFunctionReferenceFromObject() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/functionReferenceFromObject.kt"); } + @Test @TestMetadata("innerClassConstuctorReference.kt") public void testInnerClassConstuctorReference() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/innerClassConstuctorReference.kt"); } + @Test @TestMetadata("mutableBoundPropertyReferenceFromClass.kt") public void testMutableBoundPropertyReferenceFromClass() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/mutableBoundPropertyReferenceFromClass.kt"); } + @Test @TestMetadata("mutablePropertyReferenceFromClass.kt") public void testMutablePropertyReferenceFromClass() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/mutablePropertyReferenceFromClass.kt"); } + @Test @TestMetadata("privateFunctionReference.kt") public void testPrivateFunctionReference() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/privateFunctionReference.kt"); } + @Test @TestMetadata("privatePropertyReference.kt") public void testPrivatePropertyReference() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/privatePropertyReference.kt"); } + @Test @TestMetadata("propertyImportedFromObject.kt") public void testPropertyImportedFromObject() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/propertyImportedFromObject.kt"); } + @Test @TestMetadata("propertyReference.kt") public void testPropertyReference() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/propertyReference.kt"); } + @Test @TestMetadata("propertyReferenceFromClass.kt") public void testPropertyReferenceFromClass() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/propertyReferenceFromClass.kt"); } + @Test @TestMetadata("propertyReferenceFromObject.kt") public void testPropertyReferenceFromObject() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/propertyReferenceFromObject.kt"); } + @Test @TestMetadata("withInlineClassParameter.kt") public void testWithInlineClassParameter() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/withInlineClassParameter.kt"); @@ -1758,48 +1970,52 @@ public class IrCodegenBoxInlineWasmTestGenerated extends AbstractIrCodegenBoxInl } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/defaultValues/maskElimination") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class MaskElimination extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class MaskElimination { + @Test @TestMetadata("32Parameters.kt") public void test32Parameters() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/32Parameters.kt"); } + @Test @TestMetadata("33Parameters.kt") public void test33Parameters() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/33Parameters.kt"); } + @Test public void testAllFilesPresentInMaskElimination() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/maskElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt18792.kt") public void testKt18792() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/kt18792.kt"); } + @Test @TestMetadata("kt19679.kt") public void testKt19679() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/kt19679.kt"); } + @Test @TestMetadata("kt19679_2.kt") public void testKt19679_2() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/kt19679_2.kt"); } + @Test @TestMetadata("kt19679_3.kt") public void testKt19679_3() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/kt19679_3.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/simple.kt"); @@ -1807,358 +2023,374 @@ public class IrCodegenBoxInlineWasmTestGenerated extends AbstractIrCodegenBoxInl } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/delegatedProperty") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DelegatedProperty extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DelegatedProperty { + @Test public void testAllFilesPresentInDelegatedProperty() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt16864.kt") public void testKt16864() throws Exception { runTest("compiler/testData/codegen/boxInline/delegatedProperty/kt16864.kt"); } + @Test @TestMetadata("kt48498.kt") public void testKt48498() throws Exception { runTest("compiler/testData/codegen/boxInline/delegatedProperty/kt48498.kt"); } + @Test @TestMetadata("local.kt") public void testLocal() throws Exception { runTest("compiler/testData/codegen/boxInline/delegatedProperty/local.kt"); } + @Test @TestMetadata("localDeclaredInLambda.kt") public void testLocalDeclaredInLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/delegatedProperty/localDeclaredInLambda.kt"); } + @Test @TestMetadata("localInAnonymousObject.kt") public void testLocalInAnonymousObject() throws Exception { runTest("compiler/testData/codegen/boxInline/delegatedProperty/localInAnonymousObject.kt"); } + @Test @TestMetadata("localInLambda.kt") public void testLocalInLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/delegatedProperty/localInLambda.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/enclosingInfo") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class EnclosingInfo extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class EnclosingInfo { + @Test public void testAllFilesPresentInEnclosingInfo() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/enum") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Enum extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Enum { + @Test public void testAllFilesPresentInEnum() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt10569.kt") public void testKt10569() throws Exception { runTest("compiler/testData/codegen/boxInline/enum/kt10569.kt"); } + @Test @TestMetadata("kt18254.kt") public void testKt18254() throws Exception { runTest("compiler/testData/codegen/boxInline/enum/kt18254.kt"); } + @Test @TestMetadata("valueOf.kt") public void testValueOf() throws Exception { runTest("compiler/testData/codegen/boxInline/enum/valueOf.kt"); } + @Test @TestMetadata("valueOfCapturedType.kt") public void testValueOfCapturedType() throws Exception { runTest("compiler/testData/codegen/boxInline/enum/valueOfCapturedType.kt"); } + @Test @TestMetadata("valueOfChain.kt") public void testValueOfChain() throws Exception { runTest("compiler/testData/codegen/boxInline/enum/valueOfChain.kt"); } + @Test @TestMetadata("valueOfChainCapturedType.kt") public void testValueOfChainCapturedType() throws Exception { runTest("compiler/testData/codegen/boxInline/enum/valueOfChainCapturedType.kt"); } + @Test @TestMetadata("valueOfNonReified.kt") public void testValueOfNonReified() throws Exception { runTest("compiler/testData/codegen/boxInline/enum/valueOfNonReified.kt"); } + @Test @TestMetadata("values.kt") public void testValues() throws Exception { runTest("compiler/testData/codegen/boxInline/enum/values.kt"); } + @Test @TestMetadata("valuesAsArray.kt") public void testValuesAsArray() throws Exception { runTest("compiler/testData/codegen/boxInline/enum/valuesAsArray.kt"); } + @Test @TestMetadata("valuesCapturedType.kt") public void testValuesCapturedType() throws Exception { runTest("compiler/testData/codegen/boxInline/enum/valuesCapturedType.kt"); } + @Test @TestMetadata("valuesChain.kt") public void testValuesChain() throws Exception { runTest("compiler/testData/codegen/boxInline/enum/valuesChain.kt"); } + @Test @TestMetadata("valuesChainCapturedType.kt") public void testValuesChainCapturedType() throws Exception { runTest("compiler/testData/codegen/boxInline/enum/valuesChainCapturedType.kt"); } + @Test @TestMetadata("valuesNonReified.kt") public void testValuesNonReified() throws Exception { runTest("compiler/testData/codegen/boxInline/enum/valuesNonReified.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/functionExpression") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class FunctionExpression extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class FunctionExpression { + @Test public void testAllFilesPresentInFunctionExpression() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("extension.kt") public void testExtension() throws Exception { runTest("compiler/testData/codegen/boxInline/functionExpression/extension.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/inlineArgsInplace") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class InlineArgsInplace extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class InlineArgsInplace { + @Test public void testAllFilesPresentInInlineArgsInplace() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineArgsInplace"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("callArgumentReordering.kt") public void testCallArgumentReordering() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineArgsInplace/callArgumentReordering.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/inlineClasses") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class InlineClasses extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class InlineClasses { + @Test public void testAllFilesPresentInInlineClasses() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("anonymousObject.kt") public void testAnonymousObject() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/anonymousObject.kt"); } + @Test @TestMetadata("inlineClassWithInlineValReturningInlineClass.kt") public void testInlineClassWithInlineValReturningInlineClass() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/inlineClassWithInlineValReturningInlineClass.kt"); } + @Test @TestMetadata("inlineFunctionInsideInlineClassesBox.kt") public void testInlineFunctionInsideInlineClassesBox() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/inlineFunctionInsideInlineClassesBox.kt"); } + @Test @TestMetadata("noReturnTypeManglingFun.kt") public void testNoReturnTypeManglingFun() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/noReturnTypeManglingFun.kt"); } + @Test @TestMetadata("noReturnTypeManglingVal.kt") public void testNoReturnTypeManglingVal() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/noReturnTypeManglingVal.kt"); } + @Test @TestMetadata("withReturnTypeManglingFun.kt") public void testWithReturnTypeManglingFun() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/withReturnTypeManglingFun.kt"); } + @Test @TestMetadata("withReturnTypeManglingVal.kt") public void testWithReturnTypeManglingVal() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/withReturnTypeManglingVal.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class UnboxGenericParameter extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class UnboxGenericParameter { + @Test public void testAllFilesPresentInUnboxGenericParameter() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class FunInterface extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class FunInterface { + @Test public void testAllFilesPresentInFunInterface() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("any.kt") public void testAny() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface/any.kt"); } + @Test @TestMetadata("anyN.kt") public void testAnyN() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface/anyN.kt"); } + @Test @TestMetadata("iface.kt") public void testIface() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface/iface.kt"); } + @Test @TestMetadata("ifaceChild.kt") public void testIfaceChild() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface/ifaceChild.kt"); } + @Test @TestMetadata("primitive.kt") public void testPrimitive() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface/primitive.kt"); } + @Test @TestMetadata("string.kt") public void testString() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface/string.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Lambda extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Lambda { + @Test public void testAllFilesPresentInLambda() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("any.kt") public void testAny() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda/any.kt"); } + @Test @TestMetadata("anyN.kt") public void testAnyN() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda/anyN.kt"); } + @Test @TestMetadata("iface.kt") public void testIface() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda/iface.kt"); } + @Test @TestMetadata("ifaceChild.kt") public void testIfaceChild() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda/ifaceChild.kt"); } + @Test @TestMetadata("primitive.kt") public void testPrimitive() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda/primitive.kt"); } + @Test @TestMetadata("string.kt") public void testString() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda/string.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ObjectLiteral extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ObjectLiteral { + @Test public void testAllFilesPresentInObjectLiteral() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("any.kt") public void testAny() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral/any.kt"); } + @Test @TestMetadata("anyN.kt") public void testAnyN() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral/anyN.kt"); } + @Test @TestMetadata("iface.kt") public void testIface() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral/iface.kt"); } + @Test @TestMetadata("ifaceChild.kt") public void testIfaceChild() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral/ifaceChild.kt"); } + @Test @TestMetadata("primitive.kt") public void testPrimitive() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral/primitive.kt"); } + @Test @TestMetadata("string.kt") public void testString() throws Exception { runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral/string.kt"); @@ -2167,273 +2399,255 @@ public class IrCodegenBoxInlineWasmTestGenerated extends AbstractIrCodegenBoxInl } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/innerClasses") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class InnerClasses extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class InnerClasses { + @Test public void testAllFilesPresentInInnerClasses() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("captureThisAndOuter.kt") public void testCaptureThisAndOuter() throws Exception { runTest("compiler/testData/codegen/boxInline/innerClasses/captureThisAndOuter.kt"); } + @Test @TestMetadata("fakeOverride.kt") public void testFakeOverride() throws Exception { runTest("compiler/testData/codegen/boxInline/innerClasses/fakeOverride.kt"); } + @Test @TestMetadata("innerInlineFunCapturesOuter.kt") public void testInnerInlineFunCapturesOuter() throws Exception { runTest("compiler/testData/codegen/boxInline/innerClasses/innerInlineFunCapturesOuter.kt"); } + @Test @TestMetadata("innerInlineFunCapturesOuterByAnotherInlineFun.kt") public void testInnerInlineFunCapturesOuterByAnotherInlineFun() throws Exception { runTest("compiler/testData/codegen/boxInline/innerClasses/innerInlineFunCapturesOuterByAnotherInlineFun.kt"); } + @Test @TestMetadata("innerInlineFunCapturesOuterDeep.kt") public void testInnerInlineFunCapturesOuterDeep() throws Exception { runTest("compiler/testData/codegen/boxInline/innerClasses/innerInlineFunCapturesOuterDeep.kt"); } + @Test @TestMetadata("innerInlineFunCapturesOuterFunRef.kt") public void testInnerInlineFunCapturesOuterFunRef() throws Exception { runTest("compiler/testData/codegen/boxInline/innerClasses/innerInlineFunCapturesOuterFunRef.kt"); } + @Test @TestMetadata("innerInlineFunCapturesOuterWithInlineClass.kt") public void testInnerInlineFunCapturesOuterWithInlineClass() throws Exception { runTest("compiler/testData/codegen/boxInline/innerClasses/innerInlineFunCapturesOuterWithInlineClass.kt"); } + @Test @TestMetadata("kt12126.kt") public void testKt12126() throws Exception { runTest("compiler/testData/codegen/boxInline/innerClasses/kt12126.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/invokedynamic") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Invokedynamic extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Invokedynamic { + @Test public void testAllFilesPresentInInvokedynamic() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/invokedynamic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/invokedynamic/lambdas") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Lambdas extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Lambdas { + @Test public void testAllFilesPresentInLambdas() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/invokedynamic/lambdas"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/invokedynamic/sam") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Sam extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Sam { + @Test public void testAllFilesPresentInSam() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/invokedynamic/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/jvmName") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class JvmName extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class JvmName { + @Test public void testAllFilesPresentInJvmName() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/jvmPackageName") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class JvmPackageName extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class JvmPackageName { + @Test public void testAllFilesPresentInJvmPackageName() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/lambdaClassClash") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class LambdaClassClash extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class LambdaClassClash { + @Test public void testAllFilesPresentInLambdaClassClash() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaClassClash"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("lambdaClassClash.kt") public void testLambdaClassClash() throws Exception { runTest("compiler/testData/codegen/boxInline/lambdaClassClash/lambdaClassClash.kt"); } + @Test @TestMetadata("noInlineLambdaX2.kt") public void testNoInlineLambdaX2() throws Exception { runTest("compiler/testData/codegen/boxInline/lambdaClassClash/noInlineLambdaX2.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/lambdaTransformation") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class LambdaTransformation extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class LambdaTransformation { + @Test public void testAllFilesPresentInLambdaTransformation() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaTransformation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("lambdaCloning.kt") public void testLambdaCloning() throws Exception { runTest("compiler/testData/codegen/boxInline/lambdaTransformation/lambdaCloning.kt"); } + @Test @TestMetadata("lambdaInLambdaNoInline.kt") public void testLambdaInLambdaNoInline() throws Exception { runTest("compiler/testData/codegen/boxInline/lambdaTransformation/lambdaInLambdaNoInline.kt"); } + @Test @TestMetadata("regeneratedLambdaName.kt") public void testRegeneratedLambdaName() throws Exception { runTest("compiler/testData/codegen/boxInline/lambdaTransformation/regeneratedLambdaName.kt"); } + @Test @TestMetadata("regeneratedLambdaName2.kt") public void testRegeneratedLambdaName2() throws Exception { runTest("compiler/testData/codegen/boxInline/lambdaTransformation/regeneratedLambdaName2.kt"); } + @Test @TestMetadata("sameCaptured.kt") public void testSameCaptured() throws Exception { runTest("compiler/testData/codegen/boxInline/lambdaTransformation/sameCaptured.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/localFunInLambda") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class LocalFunInLambda extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class LocalFunInLambda { + @Test public void testAllFilesPresentInLocalFunInLambda() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/localFunInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("defaultParam.kt") public void testDefaultParam() throws Exception { runTest("compiler/testData/codegen/boxInline/localFunInLambda/defaultParam.kt"); } + @Test @TestMetadata("lambdaInLambdaCapturesAnotherFun.kt") public void testLambdaInLambdaCapturesAnotherFun() throws Exception { runTest("compiler/testData/codegen/boxInline/localFunInLambda/lambdaInLambdaCapturesAnotherFun.kt"); } + @Test @TestMetadata("localFunInLambda.kt") public void testLocalFunInLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/localFunInLambda/localFunInLambda.kt"); } + @Test @TestMetadata("localFunInLambdaCapturesAnotherFun.kt") public void testLocalFunInLambdaCapturesAnotherFun() throws Exception { runTest("compiler/testData/codegen/boxInline/localFunInLambda/localFunInLambdaCapturesAnotherFun.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/multiModule") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class MultiModule extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class MultiModule { + @Test public void testAllFilesPresentInMultiModule() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("tryCatchWithRecursiveInline.kt") public void testTryCatchWithRecursiveInline() throws Exception { runTest("compiler/testData/codegen/boxInline/multiModule/tryCatchWithRecursiveInline.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/multifileClasses") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class MultifileClasses extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class MultifileClasses { + @Test public void testAllFilesPresentInMultifileClasses() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/multiplatform") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Multiplatform extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Multiplatform { + @Test public void testAllFilesPresentInMultiplatform() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/multiplatform/defaultArguments") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DefaultArguments extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DefaultArguments { + @Test public void testAllFilesPresentInDefaultArguments() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("receiversAndParametersInLambda.kt") public void testReceiversAndParametersInLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/multiplatform/defaultArguments/receiversAndParametersInLambda.kt"); @@ -2441,575 +2655,640 @@ public class IrCodegenBoxInlineWasmTestGenerated extends AbstractIrCodegenBoxInl } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/noInline") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NoInline extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NoInline { + @Test public void testAllFilesPresentInNoInline() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/noInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("extensionReceiver.kt") public void testExtensionReceiver() throws Exception { runTest("compiler/testData/codegen/boxInline/noInline/extensionReceiver.kt"); } + @Test @TestMetadata("lambdaAsGeneric.kt") public void testLambdaAsGeneric() throws Exception { runTest("compiler/testData/codegen/boxInline/noInline/lambdaAsGeneric.kt"); } + @Test @TestMetadata("lambdaAsNonFunction.kt") public void testLambdaAsNonFunction() throws Exception { runTest("compiler/testData/codegen/boxInline/noInline/lambdaAsNonFunction.kt"); } + @Test @TestMetadata("noInline.kt") public void testNoInline() throws Exception { runTest("compiler/testData/codegen/boxInline/noInline/noInline.kt"); } + @Test @TestMetadata("noInlineLambdaChain.kt") public void testNoInlineLambdaChain() throws Exception { runTest("compiler/testData/codegen/boxInline/noInline/noInlineLambdaChain.kt"); } + @Test @TestMetadata("noInlineLambdaChainWithCapturedInline.kt") public void testNoInlineLambdaChainWithCapturedInline() throws Exception { runTest("compiler/testData/codegen/boxInline/noInline/noInlineLambdaChainWithCapturedInline.kt"); } + @Test @TestMetadata("withoutInline.kt") public void testWithoutInline() throws Exception { runTest("compiler/testData/codegen/boxInline/noInline/withoutInline.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NonLocalReturns extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NonLocalReturns { + @Test public void testAllFilesPresentInNonLocalReturns() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("explicitLocalReturn.kt") public void testExplicitLocalReturn() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/explicitLocalReturn.kt"); } + @Test @TestMetadata("fromArrayGenerator.kt") public void testFromArrayGenerator() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/fromArrayGenerator.kt"); } + @Test @TestMetadata("fromArrayGeneratorCatch.kt") public void testFromArrayGeneratorCatch() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/fromArrayGeneratorCatch.kt"); } + @Test @TestMetadata("fromArrayGeneratorNested.kt") public void testFromArrayGeneratorNested() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/fromArrayGeneratorNested.kt"); } + @Test @TestMetadata("fromArrayGeneratorWithCapture.kt") public void testFromArrayGeneratorWithCapture() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/fromArrayGeneratorWithCapture.kt"); } + @Test @TestMetadata("fromArrayGeneratorWithCatch.kt") public void testFromArrayGeneratorWithCatch() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/fromArrayGeneratorWithCatch.kt"); } + @Test @TestMetadata("fromArrayGeneratorWithFinally.kt") public void testFromArrayGeneratorWithFinally() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/fromArrayGeneratorWithFinally.kt"); } + @Test @TestMetadata("fromArrayGeneratorWithFinallyX2.kt") public void testFromArrayGeneratorWithFinallyX2() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/fromArrayGeneratorWithFinallyX2.kt"); } + @Test @TestMetadata("fromArrayGeneratorWithFinallyX2_2.kt") public void testFromArrayGeneratorWithFinallyX2_2() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/fromArrayGeneratorWithFinallyX2_2.kt"); } + @Test @TestMetadata("fromInterfaceDefaultGetter.kt") public void testFromInterfaceDefaultGetter() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/fromInterfaceDefaultGetter.kt"); } + @Test @TestMetadata("justReturnInLambda.kt") public void testJustReturnInLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/justReturnInLambda.kt"); } + @Test @TestMetadata("kt5199.kt") public void testKt5199() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/kt5199.kt"); } + @Test @TestMetadata("kt8948.kt") public void testKt8948() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/kt8948.kt"); } + @Test @TestMetadata("kt8948v2.kt") public void testKt8948v2() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/kt8948v2.kt"); } + @Test @TestMetadata("kt9304.kt") public void testKt9304() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/kt9304.kt"); } + @Test @TestMetadata("nestedNonLocals.kt") public void testNestedNonLocals() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/nestedNonLocals.kt"); } + @Test @TestMetadata("noInlineLocalReturn.kt") public void testNoInlineLocalReturn() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/noInlineLocalReturn.kt"); } + @Test @TestMetadata("nonLocalReturnFromOuterLambda.kt") public void testNonLocalReturnFromOuterLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/nonLocalReturnFromOuterLambda.kt"); } + @Test @TestMetadata("propertyAccessors.kt") public void testPropertyAccessors() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/propertyAccessors.kt"); } + @Test @TestMetadata("returnFromFunctionExpr.kt") public void testReturnFromFunctionExpr() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/returnFromFunctionExpr.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/simple.kt"); } + @Test @TestMetadata("simpleFunctional.kt") public void testSimpleFunctional() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/simpleFunctional.kt"); } + @Test @TestMetadata("simpleVoid.kt") public void testSimpleVoid() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/simpleVoid.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Deparenthesize extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Deparenthesize { + @Test public void testAllFilesPresentInDeparenthesize() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("bracket.kt") public void testBracket() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize/bracket.kt"); } + @Test @TestMetadata("labeled.kt") public void testLabeled() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize/labeled.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TryFinally extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class TryFinally { + @Test public void testAllFilesPresentInTryFinally() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt16417.kt") public void testKt16417() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt16417.kt"); } + @Test @TestMetadata("kt20433.kt") public void testKt20433() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt20433.kt"); } + @Test @TestMetadata("kt20433_2.kt") public void testKt20433_2() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt20433_2.kt"); } + @Test @TestMetadata("kt20433_2_void.kt") public void testKt20433_2_void() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt20433_2_void.kt"); } + @Test @TestMetadata("kt20433_void.kt") public void testKt20433_void() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt20433_void.kt"); } + @Test @TestMetadata("kt26384.kt") public void testKt26384() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt26384.kt"); } + @Test @TestMetadata("kt26384_2.kt") public void testKt26384_2() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt26384_2.kt"); } + @Test @TestMetadata("kt28546.kt") public void testKt28546() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt28546.kt"); } + @Test @TestMetadata("kt6956.kt") public void testKt6956() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt6956.kt"); } + @Test @TestMetadata("kt7273.kt") public void testKt7273() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt7273.kt"); } + @Test @TestMetadata("nonLocalReturnFromCatchBlock.kt") public void testNonLocalReturnFromCatchBlock() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/nonLocalReturnFromCatchBlock.kt"); } + @Test @TestMetadata("nonLocalReturnFromOuterLambda.kt") public void testNonLocalReturnFromOuterLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/nonLocalReturnFromOuterLambda.kt"); } + @Test @TestMetadata("nonLocalReturnToCatchBlock.kt") public void testNonLocalReturnToCatchBlock() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/nonLocalReturnToCatchBlock.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class CallSite extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class CallSite { + @Test public void testAllFilesPresentInCallSite() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("callSite.kt") public void testCallSite() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite/callSite.kt"); } + @Test @TestMetadata("callSiteComplex.kt") public void testCallSiteComplex() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite/callSiteComplex.kt"); } + @Test @TestMetadata("exceptionTableSplit.kt") public void testExceptionTableSplit() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite/exceptionTableSplit.kt"); } + @Test @TestMetadata("exceptionTableSplitNoReturn.kt") public void testExceptionTableSplitNoReturn() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite/exceptionTableSplitNoReturn.kt"); } + @Test @TestMetadata("finallyInFinally.kt") public void testFinallyInFinally() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite/finallyInFinally.kt"); } + @Test @TestMetadata("wrongVarInterval.kt") public void testWrongVarInterval() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite/wrongVarInterval.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Chained extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Chained { + @Test public void testAllFilesPresentInChained() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("finallyInFinally.kt") public void testFinallyInFinally() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/finallyInFinally.kt"); } + @Test @TestMetadata("finallyInFinally2.kt") public void testFinallyInFinally2() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/finallyInFinally2.kt"); } + @Test @TestMetadata("intReturn.kt") public void testIntReturn() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/intReturn.kt"); } + @Test @TestMetadata("intReturnComplex.kt") public void testIntReturnComplex() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/intReturnComplex.kt"); } + @Test @TestMetadata("intReturnComplex2.kt") public void testIntReturnComplex2() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/intReturnComplex2.kt"); } + @Test @TestMetadata("intReturnComplex3.kt") public void testIntReturnComplex3() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/intReturnComplex3.kt"); } + @Test @TestMetadata("intReturnComplex4.kt") public void testIntReturnComplex4() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/intReturnComplex4.kt"); } + @Test @TestMetadata("nestedLambda.kt") public void testNestedLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/nestedLambda.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DeclSite extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DeclSite { + @Test public void testAllFilesPresentInDeclSite() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("complex.kt") public void testComplex() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/complex.kt"); } + @Test @TestMetadata("intReturn.kt") public void testIntReturn() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/intReturn.kt"); } + @Test @TestMetadata("intReturnComplex.kt") public void testIntReturnComplex() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/intReturnComplex.kt"); } + @Test @TestMetadata("longReturn.kt") public void testLongReturn() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/longReturn.kt"); } + @Test @TestMetadata("nested.kt") public void testNested() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/nested.kt"); } + @Test @TestMetadata("returnInFinally.kt") public void testReturnInFinally() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/returnInFinally.kt"); } + @Test @TestMetadata("returnInTry.kt") public void testReturnInTry() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/returnInTry.kt"); } + @Test @TestMetadata("returnInTryAndFinally.kt") public void testReturnInTryAndFinally() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/returnInTryAndFinally.kt"); } + @Test @TestMetadata("severalInTry.kt") public void testSeveralInTry() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/severalInTry.kt"); } + @Test @TestMetadata("severalInTryComplex.kt") public void testSeveralInTryComplex() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/severalInTryComplex.kt"); } + @Test @TestMetadata("voidInlineFun.kt") public void testVoidInlineFun() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/voidInlineFun.kt"); } + @Test @TestMetadata("voidNonLocal.kt") public void testVoidNonLocal() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/voidNonLocal.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ExceptionTable extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ExceptionTable { + @Test public void testAllFilesPresentInExceptionTable() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("break.kt") public void testBreak() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/break.kt"); } + @Test @TestMetadata("continue.kt") public void testContinue() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/continue.kt"); } + @Test @TestMetadata("exceptionInFinally.kt") public void testExceptionInFinally() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/exceptionInFinally.kt"); } + @Test @TestMetadata("forInFinally.kt") public void testForInFinally() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/forInFinally.kt"); } + @Test @TestMetadata("innerAndExternal.kt") public void testInnerAndExternal() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/innerAndExternal.kt"); } + @Test @TestMetadata("innerAndExternalNested.kt") public void testInnerAndExternalNested() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/innerAndExternalNested.kt"); } + @Test @TestMetadata("innerAndExternalSimple.kt") public void testInnerAndExternalSimple() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/innerAndExternalSimple.kt"); } + @Test @TestMetadata("kt31653.kt") public void testKt31653() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/kt31653.kt"); } + @Test @TestMetadata("kt31653_2.kt") public void testKt31653_2() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/kt31653_2.kt"); } + @Test @TestMetadata("kt31923.kt") public void testKt31923() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/kt31923.kt"); } + @Test @TestMetadata("kt31923_2.kt") public void testKt31923_2() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/kt31923_2.kt"); } + @Test @TestMetadata("nested.kt") public void testNested() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/nested.kt"); } + @Test @TestMetadata("nestedWithReturns.kt") public void testNestedWithReturns() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/nestedWithReturns.kt"); } + @Test @TestMetadata("nestedWithReturnsSimple.kt") public void testNestedWithReturnsSimple() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/nestedWithReturnsSimple.kt"); } + @Test @TestMetadata("noFinally.kt") public void testNoFinally() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/noFinally.kt"); } + @Test @TestMetadata("severalCatchClause.kt") public void testSeveralCatchClause() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/severalCatchClause.kt"); } + @Test @TestMetadata("simpleThrow.kt") public void testSimpleThrow() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/simpleThrow.kt"); } + @Test @TestMetadata("synchonized.kt") public void testSynchonized() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/synchonized.kt"); } + @Test @TestMetadata("throwInFinally.kt") public void testThrowInFinally() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/throwInFinally.kt"); } + @Test @TestMetadata("tryCatchInFinally.kt") public void testTryCatchInFinally() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/tryCatchInFinally.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Variables extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Variables { + @Test public void testAllFilesPresentInVariables() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt7792.kt") public void testKt7792() throws Exception { runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables/kt7792.kt"); @@ -3018,385 +3297,423 @@ public class IrCodegenBoxInlineWasmTestGenerated extends AbstractIrCodegenBoxInl } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/optimizations") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Optimizations extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Optimizations { + @Test public void testAllFilesPresentInOptimizations() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt20844.kt") public void testKt20844() throws Exception { runTest("compiler/testData/codegen/boxInline/optimizations/kt20844.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/private") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Private extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Private { + @Test @TestMetadata("accessorForConst.kt") public void testAccessorForConst() throws Exception { runTest("compiler/testData/codegen/boxInline/private/accessorForConst.kt"); } + @Test @TestMetadata("accessorStability.kt") public void testAccessorStability() throws Exception { runTest("compiler/testData/codegen/boxInline/private/accessorStability.kt"); } + @Test @TestMetadata("accessorStabilityInClass.kt") public void testAccessorStabilityInClass() throws Exception { runTest("compiler/testData/codegen/boxInline/private/accessorStabilityInClass.kt"); } + @Test public void testAllFilesPresentInPrivate() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("effectivePrivate.kt") public void testEffectivePrivate() throws Exception { runTest("compiler/testData/codegen/boxInline/private/effectivePrivate.kt"); } + @Test @TestMetadata("kt6453.kt") public void testKt6453() throws Exception { runTest("compiler/testData/codegen/boxInline/private/kt6453.kt"); } + @Test @TestMetadata("kt8094.kt") public void testKt8094() throws Exception { runTest("compiler/testData/codegen/boxInline/private/kt8094.kt"); } + @Test @TestMetadata("kt8095.kt") public void testKt8095() throws Exception { runTest("compiler/testData/codegen/boxInline/private/kt8095.kt"); } + @Test @TestMetadata("nestedInPrivateClass.kt") public void testNestedInPrivateClass() throws Exception { runTest("compiler/testData/codegen/boxInline/private/nestedInPrivateClass.kt"); } + @Test @TestMetadata("nestedInPrivateClass2.kt") public void testNestedInPrivateClass2() throws Exception { runTest("compiler/testData/codegen/boxInline/private/nestedInPrivateClass2.kt"); } + @Test @TestMetadata("privateClass.kt") public void testPrivateClass() throws Exception { runTest("compiler/testData/codegen/boxInline/private/privateClass.kt"); } + @Test @TestMetadata("privateClassExtensionLambda.kt") public void testPrivateClassExtensionLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/private/privateClassExtensionLambda.kt"); } + @Test @TestMetadata("privateInline.kt") public void testPrivateInline() throws Exception { runTest("compiler/testData/codegen/boxInline/private/privateInline.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/property") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Property extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Property { + @Test public void testAllFilesPresentInProperty() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("augAssignmentAndInc.kt") public void testAugAssignmentAndInc() throws Exception { runTest("compiler/testData/codegen/boxInline/property/augAssignmentAndInc.kt"); } + @Test @TestMetadata("augAssignmentAndIncInClass.kt") public void testAugAssignmentAndIncInClass() throws Exception { runTest("compiler/testData/codegen/boxInline/property/augAssignmentAndIncInClass.kt"); } + @Test @TestMetadata("augAssignmentAndIncInClassViaConvention.kt") public void testAugAssignmentAndIncInClassViaConvention() throws Exception { runTest("compiler/testData/codegen/boxInline/property/augAssignmentAndIncInClassViaConvention.kt"); } + @Test @TestMetadata("augAssignmentAndIncOnExtension.kt") public void testAugAssignmentAndIncOnExtension() throws Exception { runTest("compiler/testData/codegen/boxInline/property/augAssignmentAndIncOnExtension.kt"); } + @Test @TestMetadata("augAssignmentAndIncOnExtensionInClass.kt") public void testAugAssignmentAndIncOnExtensionInClass() throws Exception { runTest("compiler/testData/codegen/boxInline/property/augAssignmentAndIncOnExtensionInClass.kt"); } + @Test @TestMetadata("augAssignmentAndIncViaConvention.kt") public void testAugAssignmentAndIncViaConvention() throws Exception { runTest("compiler/testData/codegen/boxInline/property/augAssignmentAndIncViaConvention.kt"); } + @Test @TestMetadata("fromObject.kt") public void testFromObject() throws Exception { runTest("compiler/testData/codegen/boxInline/property/fromObject.kt"); } + @Test @TestMetadata("kt22649.kt") public void testKt22649() throws Exception { runTest("compiler/testData/codegen/boxInline/property/kt22649.kt"); } + @Test @TestMetadata("property.kt") public void testProperty() throws Exception { runTest("compiler/testData/codegen/boxInline/property/property.kt"); } + @Test @TestMetadata("reifiedVal.kt") public void testReifiedVal() throws Exception { runTest("compiler/testData/codegen/boxInline/property/reifiedVal.kt"); } + @Test @TestMetadata("reifiedValMultiModule.kt") public void testReifiedValMultiModule() throws Exception { runTest("compiler/testData/codegen/boxInline/property/reifiedValMultiModule.kt"); } + @Test @TestMetadata("reifiedVar.kt") public void testReifiedVar() throws Exception { runTest("compiler/testData/codegen/boxInline/property/reifiedVar.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/boxInline/property/simple.kt"); } + @Test @TestMetadata("simpleExtension.kt") public void testSimpleExtension() throws Exception { runTest("compiler/testData/codegen/boxInline/property/simpleExtension.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/reified") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Reified extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Reified { + @Test public void testAllFilesPresentInReified() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("arrayConstructor.kt") public void testArrayConstructor() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/arrayConstructor.kt"); } + @Test @TestMetadata("arrayOf.kt") public void testArrayOf() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/arrayOf.kt"); } + @Test @TestMetadata("capturedLambda.kt") public void testCapturedLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/capturedLambda.kt"); } + @Test @TestMetadata("capturedLambda2.kt") public void testCapturedLambda2() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/capturedLambda2.kt"); } + @Test @TestMetadata("dontSubstituteNonReified.kt") public void testDontSubstituteNonReified() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/dontSubstituteNonReified.kt"); } + @Test @TestMetadata("kt18977.kt") public void testKt18977() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/kt18977.kt"); } + @Test @TestMetadata("kt28234.kt") public void testKt28234() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/kt28234.kt"); } + @Test @TestMetadata("kt35511.kt") public void testKt35511() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/kt35511.kt"); } + @Test @TestMetadata("kt35511_try.kt") public void testKt35511_try() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/kt35511_try.kt"); } + @Test @TestMetadata("kt35511_try_valueOf.kt") public void testKt35511_try_valueOf() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/kt35511_try_valueOf.kt"); } + @Test @TestMetadata("kt35511_try_values.kt") public void testKt35511_try_values() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/kt35511_try_values.kt"); } + @Test @TestMetadata("kt46584.kt") public void testKt46584() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/kt46584.kt"); } + @Test @TestMetadata("kt46584_2.kt") public void testKt46584_2() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/kt46584_2.kt"); } + @Test @TestMetadata("kt7017.kt") public void testKt7017() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/kt7017.kt"); } + @Test @TestMetadata("kt8047.kt") public void testKt8047() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/kt8047.kt"); } + @Test @TestMetadata("kt8047_2.kt") public void testKt8047_2() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/kt8047_2.kt"); } + @Test @TestMetadata("kt9637_2.kt") public void testKt9637_2() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/kt9637_2.kt"); } + @Test @TestMetadata("nameClash.kt") public void testNameClash() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/nameClash.kt"); } + @Test @TestMetadata("nonCapturingObjectInLambda.kt") public void testNonCapturingObjectInLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/nonCapturingObjectInLambda.kt"); } + @Test @TestMetadata("singletonLambda.kt") public void testSingletonLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/singletonLambda.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/reified/checkCast") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class CheckCast extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class CheckCast { + @Test public void testAllFilesPresentInCheckCast() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/checkCast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("chain.kt") public void testChain() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/checkCast/chain.kt"); } + @Test @TestMetadata("kt26435.kt") public void testKt26435() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/checkCast/kt26435.kt"); } + @Test @TestMetadata("kt26435_2.kt") public void testKt26435_2() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/checkCast/kt26435_2.kt"); } + @Test @TestMetadata("kt26435_3.kt") public void testKt26435_3() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/checkCast/kt26435_3.kt"); } + @Test @TestMetadata("kt8043.kt") public void testKt8043() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/checkCast/kt8043.kt"); } + @Test @TestMetadata("maxStack.kt") public void testMaxStack() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/checkCast/maxStack.kt"); } + @Test @TestMetadata("nullable.kt") public void testNullable() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/checkCast/nullable.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/checkCast/simple.kt"); } + @Test @TestMetadata("simpleSafe.kt") public void testSimpleSafe() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/checkCast/simpleSafe.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/reified/defaultLambda") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DefaultLambda extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DefaultLambda { + @Test public void testAllFilesPresentInDefaultLambda() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/reified/isCheck") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class IsCheck extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class IsCheck { + @Test public void testAllFilesPresentInIsCheck() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/isCheck"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("chain.kt") public void testChain() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/isCheck/chain.kt"); } + @Test @TestMetadata("nullable.kt") public void testNullable() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/isCheck/nullable.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/boxInline/reified/isCheck/simple.kt"); @@ -3404,481 +3721,527 @@ public class IrCodegenBoxInlineWasmTestGenerated extends AbstractIrCodegenBoxInl } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/signature") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Signature extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Signature { + @Test public void testAllFilesPresentInSignature() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/signatureMangling") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SignatureMangling extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class SignatureMangling { + @Test public void testAllFilesPresentInSignatureMangling() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signatureMangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/simple") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Simple extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Simple { + @Test public void testAllFilesPresentInSimple() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/simple"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("captureAndArgumentIncompatibleTypes.kt") public void testCaptureAndArgumentIncompatibleTypes() throws Exception { runTest("compiler/testData/codegen/boxInline/simple/captureAndArgumentIncompatibleTypes.kt"); } + @Test @TestMetadata("classObject.kt") public void testClassObject() throws Exception { runTest("compiler/testData/codegen/boxInline/simple/classObject.kt"); } + @Test @TestMetadata("destructuring.kt") public void testDestructuring() throws Exception { runTest("compiler/testData/codegen/boxInline/simple/destructuring.kt"); } + @Test @TestMetadata("destructuringIndexClash.kt") public void testDestructuringIndexClash() throws Exception { runTest("compiler/testData/codegen/boxInline/simple/destructuringIndexClash.kt"); } + @Test @TestMetadata("extension.kt") public void testExtension() throws Exception { runTest("compiler/testData/codegen/boxInline/simple/extension.kt"); } + @Test @TestMetadata("extensionLambda.kt") public void testExtensionLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/simple/extensionLambda.kt"); } + @Test @TestMetadata("funImportedFromObject.kt") public void testFunImportedFromObject() throws Exception { runTest("compiler/testData/codegen/boxInline/simple/funImportedFromObject.kt"); } + @Test @TestMetadata("inlineCallInInlineLambda.kt") public void testInlineCallInInlineLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/simple/inlineCallInInlineLambda.kt"); } + @Test @TestMetadata("kt17431.kt") public void testKt17431() throws Exception { runTest("compiler/testData/codegen/boxInline/simple/kt17431.kt"); } + @Test @TestMetadata("kt28547.kt") public void testKt28547() throws Exception { runTest("compiler/testData/codegen/boxInline/simple/kt28547.kt"); } + @Test @TestMetadata("kt28547_2.kt") public void testKt28547_2() throws Exception { runTest("compiler/testData/codegen/boxInline/simple/kt28547_2.kt"); } + @Test @TestMetadata("params.kt") public void testParams() throws Exception { runTest("compiler/testData/codegen/boxInline/simple/params.kt"); } + @Test @TestMetadata("rootConstructor.kt") public void testRootConstructor() throws Exception { runTest("compiler/testData/codegen/boxInline/simple/rootConstructor.kt"); } + @Test @TestMetadata("safeCall.kt") public void testSafeCall() throws Exception { runTest("compiler/testData/codegen/boxInline/simple/safeCall.kt"); } + @Test @TestMetadata("severalClosures.kt") public void testSeveralClosures() throws Exception { runTest("compiler/testData/codegen/boxInline/simple/severalClosures.kt"); } + @Test @TestMetadata("severalUsage.kt") public void testSeveralUsage() throws Exception { runTest("compiler/testData/codegen/boxInline/simple/severalUsage.kt"); } + @Test @TestMetadata("simpleDouble.kt") public void testSimpleDouble() throws Exception { runTest("compiler/testData/codegen/boxInline/simple/simpleDouble.kt"); } + @Test @TestMetadata("simpleEnum.kt") public void testSimpleEnum() throws Exception { runTest("compiler/testData/codegen/boxInline/simple/simpleEnum.kt"); } + @Test @TestMetadata("simpleGenerics.kt") public void testSimpleGenerics() throws Exception { runTest("compiler/testData/codegen/boxInline/simple/simpleGenerics.kt"); } + @Test @TestMetadata("simpleInt.kt") public void testSimpleInt() throws Exception { runTest("compiler/testData/codegen/boxInline/simple/simpleInt.kt"); } + @Test @TestMetadata("simpleLambda.kt") public void testSimpleLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/simple/simpleLambda.kt"); } + @Test @TestMetadata("simpleObject.kt") public void testSimpleObject() throws Exception { runTest("compiler/testData/codegen/boxInline/simple/simpleObject.kt"); } + @Test @TestMetadata("vararg.kt") public void testVararg() throws Exception { runTest("compiler/testData/codegen/boxInline/simple/vararg.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/smap") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Smap extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Smap { + @Test public void testAllFilesPresentInSmap() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("assertion.kt") public void testAssertion() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/assertion.kt"); } + @Test @TestMetadata("classCycle.kt") public void testClassCycle() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/classCycle.kt"); } + @Test @TestMetadata("classFromDefaultPackage.kt") public void testClassFromDefaultPackage() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/classFromDefaultPackage.kt"); } + @Test @TestMetadata("coroutinesWithTailCallOtpimization.kt") public void testCoroutinesWithTailCallOtpimization() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/coroutinesWithTailCallOtpimization.kt"); } + @Test @TestMetadata("crossroutines.kt") public void testCrossroutines() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/crossroutines.kt"); } + @Test @TestMetadata("defaultFunction.kt") public void testDefaultFunction() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/defaultFunction.kt"); } + @Test @TestMetadata("defaultFunctionWithInlineCall.kt") public void testDefaultFunctionWithInlineCall() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/defaultFunctionWithInlineCall.kt"); } + @Test @TestMetadata("forInline.kt") public void testForInline() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/forInline.kt"); } + @Test @TestMetadata("inlineProperty.kt") public void testInlineProperty() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/inlineProperty.kt"); } + @Test @TestMetadata("interleavedFiles.kt") public void testInterleavedFiles() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/interleavedFiles.kt"); } + @Test @TestMetadata("kt23369.kt") public void testKt23369() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/kt23369.kt"); } + @Test @TestMetadata("kt23369_2.kt") public void testKt23369_2() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/kt23369_2.kt"); } + @Test @TestMetadata("kt23369_3.kt") public void testKt23369_3() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/kt23369_3.kt"); } + @Test @TestMetadata("kt35006.kt") public void testKt35006() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/kt35006.kt"); } + @Test @TestMetadata("oneFile.kt") public void testOneFile() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/oneFile.kt"); } + @Test @TestMetadata("rangeFolding.kt") public void testRangeFolding() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/rangeFolding.kt"); } + @Test @TestMetadata("rangeFoldingInClass.kt") public void testRangeFoldingInClass() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/rangeFoldingInClass.kt"); } + @Test @TestMetadata("smap.kt") public void testSmap() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/smap.kt"); } + @Test @TestMetadata("smapWithNewSyntax.kt") public void testSmapWithNewSyntax() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/smapWithNewSyntax.kt"); } + @Test @TestMetadata("smapWithOldSyntax.kt") public void testSmapWithOldSyntax() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/smapWithOldSyntax.kt"); } + @Test @TestMetadata("tryFinally1.kt") public void testTryFinally1() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/tryFinally1.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/smap/anonymous") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Anonymous extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Anonymous { + @Test public void testAllFilesPresentInAnonymous() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt19175.kt") public void testKt19175() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/anonymous/kt19175.kt"); } + @Test @TestMetadata("lambda.kt") public void testLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/anonymous/lambda.kt"); } + @Test @TestMetadata("lambdaOnCallSite.kt") public void testLambdaOnCallSite() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/anonymous/lambdaOnCallSite.kt"); } + @Test @TestMetadata("lambdaOnInlineCallSite.kt") public void testLambdaOnInlineCallSite() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/anonymous/lambdaOnInlineCallSite.kt"); } + @Test @TestMetadata("object.kt") public void testObject() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/anonymous/object.kt"); } + @Test @TestMetadata("objectOnCallSite.kt") public void testObjectOnCallSite() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/anonymous/objectOnCallSite.kt"); } + @Test @TestMetadata("objectOnInlineCallSite.kt") public void testObjectOnInlineCallSite() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/anonymous/objectOnInlineCallSite.kt"); } + @Test @TestMetadata("objectOnInlineCallSite2.kt") public void testObjectOnInlineCallSite2() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/anonymous/objectOnInlineCallSite2.kt"); } + @Test @TestMetadata("objectOnInlineCallSiteWithCapture.kt") public void testObjectOnInlineCallSiteWithCapture() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/anonymous/objectOnInlineCallSiteWithCapture.kt"); } + @Test @TestMetadata("severalMappingsForDefaultFile.kt") public void testSeveralMappingsForDefaultFile() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/anonymous/severalMappingsForDefaultFile.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/smap/defaultLambda") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DefaultLambda extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DefaultLambda { + @Test public void testAllFilesPresentInDefaultLambda() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("defaultLambdaInAnonymous.kt") public void testDefaultLambdaInAnonymous() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/defaultLambdaInAnonymous.kt"); } + @Test @TestMetadata("inlineAnonymousInDefault.kt") public void testInlineAnonymousInDefault() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/inlineAnonymousInDefault.kt"); } + @Test @TestMetadata("inlineAnonymousInDefault2.kt") public void testInlineAnonymousInDefault2() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/inlineAnonymousInDefault2.kt"); } + @Test @TestMetadata("inlineInDefault.kt") public void testInlineInDefault() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/inlineInDefault.kt"); } + @Test @TestMetadata("inlineInDefault2.kt") public void testInlineInDefault2() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/inlineInDefault2.kt"); } + @Test @TestMetadata("kt21827.kt") public void testKt21827() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/kt21827.kt"); } + @Test @TestMetadata("nested.kt") public void testNested() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/nested.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/simple.kt"); } + @Test @TestMetadata("simple2.kt") public void testSimple2() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/simple2.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/smap/inlineOnly") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class InlineOnly extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class InlineOnly { + @Test public void testAllFilesPresentInInlineOnly() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/inlineOnly"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("noSmap.kt") public void testNoSmap() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/inlineOnly/noSmap.kt"); } + @Test @TestMetadata("noSmapWithProperty.kt") public void testNoSmapWithProperty() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/inlineOnly/noSmapWithProperty.kt"); } + @Test @TestMetadata("stdlibInlineOnly.kt") public void testStdlibInlineOnly() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/inlineOnly/stdlibInlineOnly.kt"); } + @Test @TestMetadata("stdlibInlineOnlyOneLine.kt") public void testStdlibInlineOnlyOneLine() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/inlineOnly/stdlibInlineOnlyOneLine.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/smap/newsmap") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Newsmap extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Newsmap { + @Test public void testAllFilesPresentInNewsmap() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/newsmap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("differentMapping.kt") public void testDifferentMapping() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/newsmap/differentMapping.kt"); } + @Test @TestMetadata("mappingInInlineFunLambda.kt") public void testMappingInInlineFunLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/newsmap/mappingInInlineFunLambda.kt"); } + @Test @TestMetadata("mappingInSubInlineLambda.kt") public void testMappingInSubInlineLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/newsmap/mappingInSubInlineLambda.kt"); } + @Test @TestMetadata("mappingInSubInlineLambdaSameFileInline.kt") public void testMappingInSubInlineLambdaSameFileInline() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/newsmap/mappingInSubInlineLambdaSameFileInline.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/smap/resolve") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Resolve extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Resolve { + @Test public void testAllFilesPresentInResolve() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/resolve"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("inlineComponent.kt") public void testInlineComponent() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/resolve/inlineComponent.kt"); } + @Test @TestMetadata("inlineIterator.kt") public void testInlineIterator() throws Exception { runTest("compiler/testData/codegen/boxInline/smap/resolve/inlineIterator.kt"); @@ -3886,601 +4249,671 @@ public class IrCodegenBoxInlineWasmTestGenerated extends AbstractIrCodegenBoxInl } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/special") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Special extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Special { + @Test public void testAllFilesPresentInSpecial() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/special"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("identityCheck.kt") public void testIdentityCheck() throws Exception { runTest("compiler/testData/codegen/boxInline/special/identityCheck.kt"); } + @Test @TestMetadata("ifBranches.kt") public void testIfBranches() throws Exception { runTest("compiler/testData/codegen/boxInline/special/ifBranches.kt"); } + @Test @TestMetadata("iinc.kt") public void testIinc() throws Exception { runTest("compiler/testData/codegen/boxInline/special/iinc.kt"); } + @Test @TestMetadata("inlineChain.kt") public void testInlineChain() throws Exception { runTest("compiler/testData/codegen/boxInline/special/inlineChain.kt"); } + @Test @TestMetadata("loopInStoreLoadChains.kt") public void testLoopInStoreLoadChains() throws Exception { runTest("compiler/testData/codegen/boxInline/special/loopInStoreLoadChains.kt"); } + @Test @TestMetadata("loopInStoreLoadChains2.kt") public void testLoopInStoreLoadChains2() throws Exception { runTest("compiler/testData/codegen/boxInline/special/loopInStoreLoadChains2.kt"); } + @Test @TestMetadata("plusAssign.kt") public void testPlusAssign() throws Exception { runTest("compiler/testData/codegen/boxInline/special/plusAssign.kt"); } + @Test @TestMetadata("stackHeightBug.kt") public void testStackHeightBug() throws Exception { runTest("compiler/testData/codegen/boxInline/special/stackHeightBug.kt"); } + @Test @TestMetadata("unusedInlineLambda.kt") public void testUnusedInlineLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/special/unusedInlineLambda.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/stackOnReturn") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class StackOnReturn extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class StackOnReturn { + @Test public void testAllFilesPresentInStackOnReturn() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/stackOnReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("elvis.kt") public void testElvis() throws Exception { runTest("compiler/testData/codegen/boxInline/stackOnReturn/elvis.kt"); } + @Test @TestMetadata("ifThenElse.kt") public void testIfThenElse() throws Exception { runTest("compiler/testData/codegen/boxInline/stackOnReturn/ifThenElse.kt"); } + @Test @TestMetadata("kt11499.kt") public void testKt11499() throws Exception { runTest("compiler/testData/codegen/boxInline/stackOnReturn/kt11499.kt"); } + @Test @TestMetadata("kt17591.kt") public void testKt17591() throws Exception { runTest("compiler/testData/codegen/boxInline/stackOnReturn/kt17591.kt"); } + @Test @TestMetadata("kt17591a.kt") public void testKt17591a() throws Exception { runTest("compiler/testData/codegen/boxInline/stackOnReturn/kt17591a.kt"); } + @Test @TestMetadata("kt17591b.kt") public void testKt17591b() throws Exception { runTest("compiler/testData/codegen/boxInline/stackOnReturn/kt17591b.kt"); } + @Test @TestMetadata("mixedTypesOnStack1.kt") public void testMixedTypesOnStack1() throws Exception { runTest("compiler/testData/codegen/boxInline/stackOnReturn/mixedTypesOnStack1.kt"); } + @Test @TestMetadata("mixedTypesOnStack2.kt") public void testMixedTypesOnStack2() throws Exception { runTest("compiler/testData/codegen/boxInline/stackOnReturn/mixedTypesOnStack2.kt"); } + @Test @TestMetadata("mixedTypesOnStack3.kt") public void testMixedTypesOnStack3() throws Exception { runTest("compiler/testData/codegen/boxInline/stackOnReturn/mixedTypesOnStack3.kt"); } + @Test @TestMetadata("nonLocalReturn1.kt") public void testNonLocalReturn1() throws Exception { runTest("compiler/testData/codegen/boxInline/stackOnReturn/nonLocalReturn1.kt"); } + @Test @TestMetadata("nonLocalReturn2.kt") public void testNonLocalReturn2() throws Exception { runTest("compiler/testData/codegen/boxInline/stackOnReturn/nonLocalReturn2.kt"); } + @Test @TestMetadata("nonLocalReturn3.kt") public void testNonLocalReturn3() throws Exception { runTest("compiler/testData/codegen/boxInline/stackOnReturn/nonLocalReturn3.kt"); } + @Test @TestMetadata("poppedLocalReturn.kt") public void testPoppedLocalReturn() throws Exception { runTest("compiler/testData/codegen/boxInline/stackOnReturn/poppedLocalReturn.kt"); } + @Test @TestMetadata("poppedLocalReturn2.kt") public void testPoppedLocalReturn2() throws Exception { runTest("compiler/testData/codegen/boxInline/stackOnReturn/poppedLocalReturn2.kt"); } + @Test @TestMetadata("returnLong.kt") public void testReturnLong() throws Exception { runTest("compiler/testData/codegen/boxInline/stackOnReturn/returnLong.kt"); } + @Test @TestMetadata("tryFinally.kt") public void testTryFinally() throws Exception { runTest("compiler/testData/codegen/boxInline/stackOnReturn/tryFinally.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/suspend") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Suspend extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Suspend { + @Test public void testAllFilesPresentInSuspend() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("capturedVariables.kt") public void testCapturedVariables() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/capturedVariables.kt"); } + @Test @TestMetadata("crossinlineSuspendLambdaInsideCrossinlineSuspendLambda.kt") public void testCrossinlineSuspendLambdaInsideCrossinlineSuspendLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/crossinlineSuspendLambdaInsideCrossinlineSuspendLambda.kt"); } + @Test @TestMetadata("delegatedProperties.kt") public void testDelegatedProperties() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/delegatedProperties.kt"); } + @Test @TestMetadata("doubleRegenerationWithNonSuspendingLambda.kt") public void testDoubleRegenerationWithNonSuspendingLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/doubleRegenerationWithNonSuspendingLambda.kt"); } + @Test @TestMetadata("inlineOrdinaryOfCrossinlineSuspend.kt") public void testInlineOrdinaryOfCrossinlineSuspend() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/inlineOrdinaryOfCrossinlineSuspend.kt"); } + @Test @TestMetadata("inlineOrdinaryOfNoinlineSuspend.kt") public void testInlineOrdinaryOfNoinlineSuspend() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/inlineOrdinaryOfNoinlineSuspend.kt"); } + @Test @TestMetadata("inlinePassthrough.kt") public void testInlinePassthrough() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/inlinePassthrough.kt"); } + @Test @TestMetadata("inlineSuspendOfCrossinlineOrdinary.kt") public void testInlineSuspendOfCrossinlineOrdinary() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/inlineSuspendOfCrossinlineOrdinary.kt"); } + @Test @TestMetadata("inlineSuspendOfCrossinlineSuspend.kt") public void testInlineSuspendOfCrossinlineSuspend() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/inlineSuspendOfCrossinlineSuspend.kt"); } + @Test @TestMetadata("inlineSuspendOfNoinlineOrdinary.kt") public void testInlineSuspendOfNoinlineOrdinary() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/inlineSuspendOfNoinlineOrdinary.kt"); } + @Test @TestMetadata("inlineSuspendOfNoinlineSuspend.kt") public void testInlineSuspendOfNoinlineSuspend() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/inlineSuspendOfNoinlineSuspend.kt"); } + @Test @TestMetadata("inlineSuspendOfOrdinary.kt") public void testInlineSuspendOfOrdinary() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/inlineSuspendOfOrdinary.kt"); } + @Test @TestMetadata("inlineSuspendOfSuspend.kt") public void testInlineSuspendOfSuspend() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/inlineSuspendOfSuspend.kt"); } + @Test @TestMetadata("kt26658.kt") public void testKt26658() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/kt26658.kt"); } + @Test @TestMetadata("maxStackWithCrossinline.kt") public void testMaxStackWithCrossinline() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/maxStackWithCrossinline.kt"); } + @Test @TestMetadata("multipleLocals.kt") public void testMultipleLocals() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/multipleLocals.kt"); } + @Test @TestMetadata("multipleSuspensionPoints.kt") public void testMultipleSuspensionPoints() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/multipleSuspensionPoints.kt"); } + @Test @TestMetadata("nonLocalReturn.kt") public void testNonLocalReturn() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/nonLocalReturn.kt"); } + @Test @TestMetadata("nonSuspendCrossinline.kt") public void testNonSuspendCrossinline() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/nonSuspendCrossinline.kt"); } + @Test @TestMetadata("returnValue.kt") public void testReturnValue() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/returnValue.kt"); } + @Test @TestMetadata("tryCatchReceiver.kt") public void testTryCatchReceiver() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/tryCatchReceiver.kt"); } + @Test @TestMetadata("tryCatchStackTransform.kt") public void testTryCatchStackTransform() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/tryCatchStackTransform.kt"); } + @Test @TestMetadata("twiceRegeneratedAnonymousObject.kt") public void testTwiceRegeneratedAnonymousObject() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/twiceRegeneratedAnonymousObject.kt"); } + @Test @TestMetadata("twiceRegeneratedSuspendLambda.kt") public void testTwiceRegeneratedSuspendLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/twiceRegeneratedSuspendLambda.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/suspend/callableReference") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class CallableReference extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class CallableReference { + @Test public void testAllFilesPresentInCallableReference() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("isAsReified.kt") public void testIsAsReified() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/callableReference/isAsReified.kt"); } + @Test @TestMetadata("isAsReified2.kt") public void testIsAsReified2() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/callableReference/isAsReified2.kt"); } + @Test @TestMetadata("nonTailCall.kt") public void testNonTailCall() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/callableReference/nonTailCall.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/callableReference/simple.kt"); } + @Test @TestMetadata("unitReturn.kt") public void testUnitReturn() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/callableReference/unitReturn.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/suspend/defaultParameter") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DefaultParameter extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DefaultParameter { + @Test public void testAllFilesPresentInDefaultParameter() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/defaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("defaultInlineLambda.kt") public void testDefaultInlineLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/defaultParameter/defaultInlineLambda.kt"); } + @Test @TestMetadata("defaultInlineReference.kt") public void testDefaultInlineReference() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/defaultParameter/defaultInlineReference.kt"); } + @Test @TestMetadata("defaultValueCrossinline.kt") public void testDefaultValueCrossinline() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/defaultParameter/defaultValueCrossinline.kt"); } + @Test @TestMetadata("defaultValueInClass.kt") public void testDefaultValueInClass() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/defaultParameter/defaultValueInClass.kt"); } + @Test @TestMetadata("defaultValueInline.kt") public void testDefaultValueInline() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/defaultParameter/defaultValueInline.kt"); } + @Test @TestMetadata("defaultValueInlineFromMultiFileFacade.kt") public void testDefaultValueInlineFromMultiFileFacade() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/defaultParameter/defaultValueInlineFromMultiFileFacade.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/suspend/inlineClass") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class InlineClass extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class InlineClass { + @Test public void testAllFilesPresentInInlineClass() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("returnBoxedFromLambda.kt") public void testReturnBoxedFromLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/inlineClass/returnBoxedFromLambda.kt"); } + @Test @TestMetadata("returnUnboxedDirect.kt") public void testReturnUnboxedDirect() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/inlineClass/returnUnboxedDirect.kt"); } + @Test @TestMetadata("returnUnboxedFromLambda.kt") public void testReturnUnboxedFromLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/inlineClass/returnUnboxedFromLambda.kt"); } + @Test @TestMetadata("returnUnboxedResume.kt") public void testReturnUnboxedResume() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/inlineClass/returnUnboxedResume.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class InlineUsedAsNoinline extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class InlineUsedAsNoinline { + @Test public void testAllFilesPresentInInlineUsedAsNoinline() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("inlineOnly.kt") public void testInlineOnly() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline/inlineOnly.kt"); } + @Test @TestMetadata("simpleNamed.kt") public void testSimpleNamed() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline/simpleNamed.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/suspend/receiver") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Receiver extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Receiver { + @Test public void testAllFilesPresentInReceiver() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/receiver"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("inlineOrdinaryOfCrossinlineSuspend.kt") public void testInlineOrdinaryOfCrossinlineSuspend() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/receiver/inlineOrdinaryOfCrossinlineSuspend.kt"); } + @Test @TestMetadata("inlineOrdinaryOfNoinlineSuspend.kt") public void testInlineOrdinaryOfNoinlineSuspend() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/receiver/inlineOrdinaryOfNoinlineSuspend.kt"); } + @Test @TestMetadata("inlineSuspendOfCrossinlineOrdinary.kt") public void testInlineSuspendOfCrossinlineOrdinary() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfCrossinlineOrdinary.kt"); } + @Test @TestMetadata("inlineSuspendOfCrossinlineSuspend.kt") public void testInlineSuspendOfCrossinlineSuspend() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfCrossinlineSuspend.kt"); } + @Test @TestMetadata("inlineSuspendOfNoinlineOrdinary.kt") public void testInlineSuspendOfNoinlineOrdinary() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfNoinlineOrdinary.kt"); } + @Test @TestMetadata("inlineSuspendOfNoinlineSuspend.kt") public void testInlineSuspendOfNoinlineSuspend() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfNoinlineSuspend.kt"); } + @Test @TestMetadata("inlineSuspendOfOrdinary.kt") public void testInlineSuspendOfOrdinary() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfOrdinary.kt"); } + @Test @TestMetadata("inlineSuspendOfSuspend.kt") public void testInlineSuspendOfSuspend() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfSuspend.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/suspend/stateMachine") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class StateMachine extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class StateMachine { + @Test public void testAllFilesPresentInStateMachine() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("crossingCoroutineBoundaries.kt") public void testCrossingCoroutineBoundaries() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/crossingCoroutineBoundaries.kt"); } + @Test @TestMetadata("independentInline.kt") public void testIndependentInline() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/independentInline.kt"); } + @Test @TestMetadata("innerLambda.kt") public void testInnerLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/innerLambda.kt"); } + @Test @TestMetadata("innerLambdaInsideLambda.kt") public void testInnerLambdaInsideLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/innerLambdaInsideLambda.kt"); } + @Test @TestMetadata("innerLambdaWithoutCrossinline.kt") public void testInnerLambdaWithoutCrossinline() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/innerLambdaWithoutCrossinline.kt"); } + @Test @TestMetadata("innerMadness.kt") public void testInnerMadness() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/innerMadness.kt"); } + @Test @TestMetadata("innerMadnessCallSite.kt") public void testInnerMadnessCallSite() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/innerMadnessCallSite.kt"); } + @Test @TestMetadata("innerObject.kt") public void testInnerObject() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/innerObject.kt"); } + @Test @TestMetadata("innerObjectInsideInnerObject.kt") public void testInnerObjectInsideInnerObject() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/innerObjectInsideInnerObject.kt"); } + @Test @TestMetadata("innerObjectRetransformation.kt") public void testInnerObjectRetransformation() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/innerObjectRetransformation.kt"); } + @Test @TestMetadata("innerObjectSeveralFunctions.kt") public void testInnerObjectSeveralFunctions() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/innerObjectSeveralFunctions.kt"); } + @Test @TestMetadata("innerObjectWithoutCapturingCrossinline.kt") public void testInnerObjectWithoutCapturingCrossinline() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/innerObjectWithoutCapturingCrossinline.kt"); } + @Test @TestMetadata("insideObject.kt") public void testInsideObject() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/insideObject.kt"); } + @Test @TestMetadata("kt30708.kt") public void testKt30708() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/kt30708.kt"); } + @Test @TestMetadata("lambdaTransformation.kt") public void testLambdaTransformation() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/lambdaTransformation.kt"); } + @Test @TestMetadata("normalInline.kt") public void testNormalInline() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/normalInline.kt"); } + @Test @TestMetadata("numberOfSuspentions.kt") public void testNumberOfSuspentions() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/numberOfSuspentions.kt"); } + @Test @TestMetadata("objectInsideLambdas.kt") public void testObjectInsideLambdas() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/objectInsideLambdas.kt"); } + @Test @TestMetadata("oneInlineTwoCaptures.kt") public void testOneInlineTwoCaptures() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/oneInlineTwoCaptures.kt"); } + @Test @TestMetadata("passLambda.kt") public void testPassLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/passLambda.kt"); } + @Test @TestMetadata("passParameter.kt") public void testPassParameter() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/passParameter.kt"); } + @Test @TestMetadata("passParameterLambda.kt") public void testPassParameterLambda() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/passParameterLambda.kt"); } + @Test @TestMetadata("unreachableSuspendMarker.kt") public void testUnreachableSuspendMarker() throws Exception { runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/unreachableSuspendMarker.kt"); @@ -4488,110 +4921,121 @@ public class IrCodegenBoxInlineWasmTestGenerated extends AbstractIrCodegenBoxInl } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/syntheticAccessors") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SyntheticAccessors extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class SyntheticAccessors { + @Test public void testAllFilesPresentInSyntheticAccessors() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("constField.kt") public void testConstField() throws Exception { runTest("compiler/testData/codegen/boxInline/syntheticAccessors/constField.kt"); } + @Test @TestMetadata("packagePrivateMembers.kt") public void testPackagePrivateMembers() throws Exception { runTest("compiler/testData/codegen/boxInline/syntheticAccessors/packagePrivateMembers.kt"); } + @Test @TestMetadata("propertyModifiers.kt") public void testPropertyModifiers() throws Exception { runTest("compiler/testData/codegen/boxInline/syntheticAccessors/propertyModifiers.kt"); } + @Test @TestMetadata("protectedMembers.kt") public void testProtectedMembers() throws Exception { runTest("compiler/testData/codegen/boxInline/syntheticAccessors/protectedMembers.kt"); } + @Test @TestMetadata("protectedMembersFromSuper.kt") public void testProtectedMembersFromSuper() throws Exception { runTest("compiler/testData/codegen/boxInline/syntheticAccessors/protectedMembersFromSuper.kt"); } + @Test @TestMetadata("superCall.kt") public void testSuperCall() throws Exception { runTest("compiler/testData/codegen/boxInline/syntheticAccessors/superCall.kt"); } + @Test @TestMetadata("superCallFromMultipleSubclasses.kt") public void testSuperCallFromMultipleSubclasses() throws Exception { runTest("compiler/testData/codegen/boxInline/syntheticAccessors/superCallFromMultipleSubclasses.kt"); } + @Test @TestMetadata("superProperty.kt") public void testSuperProperty() throws Exception { runTest("compiler/testData/codegen/boxInline/syntheticAccessors/superProperty.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class WithinInlineLambda extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class WithinInlineLambda { + @Test public void testAllFilesPresentInWithinInlineLambda() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("directFieldAccess.kt") public void testDirectFieldAccess() throws Exception { runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/directFieldAccess.kt"); } + @Test @TestMetadata("directFieldAccessInCrossInline.kt") public void testDirectFieldAccessInCrossInline() throws Exception { runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/directFieldAccessInCrossInline.kt"); } + @Test @TestMetadata("privateCall.kt") public void testPrivateCall() throws Exception { runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/privateCall.kt"); } + @Test @TestMetadata("privateInCrossInline.kt") public void testPrivateInCrossInline() throws Exception { runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/privateInCrossInline.kt"); } + @Test @TestMetadata("privateInDefaultStubArgument.kt") public void testPrivateInDefaultStubArgument() throws Exception { runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/privateInDefaultStubArgument.kt"); } + @Test @TestMetadata("protectedInCrossinline.kt") public void testProtectedInCrossinline() throws Exception { runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/protectedInCrossinline.kt"); } + @Test @TestMetadata("protectedMembersFromSuper.kt") public void testProtectedMembersFromSuper() throws Exception { runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/protectedMembersFromSuper.kt"); } + @Test @TestMetadata("superCall.kt") public void testSuperCall() throws Exception { runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/superCall.kt"); } + @Test @TestMetadata("superInCrossInline.kt") public void testSuperInCrossInline() throws Exception { runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/superInCrossInline.kt"); @@ -4599,79 +5043,78 @@ public class IrCodegenBoxInlineWasmTestGenerated extends AbstractIrCodegenBoxInl } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/trait") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Trait extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Trait { + @Test public void testAllFilesPresentInTrait() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("trait.kt") public void testTrait() throws Exception { runTest("compiler/testData/codegen/boxInline/trait/trait.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/tryCatchFinally") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TryCatchFinally extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class TryCatchFinally { + @Test public void testAllFilesPresentInTryCatchFinally() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt5863.kt") public void testKt5863() throws Exception { runTest("compiler/testData/codegen/boxInline/tryCatchFinally/kt5863.kt"); } + @Test @TestMetadata("tryCatch.kt") public void testTryCatch() throws Exception { runTest("compiler/testData/codegen/boxInline/tryCatchFinally/tryCatch.kt"); } + @Test @TestMetadata("tryCatch2.kt") public void testTryCatch2() throws Exception { runTest("compiler/testData/codegen/boxInline/tryCatchFinally/tryCatch2.kt"); } + @Test @TestMetadata("tryCatchFinally.kt") public void testTryCatchFinally() throws Exception { runTest("compiler/testData/codegen/boxInline/tryCatchFinally/tryCatchFinally.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/boxInline/varargs") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Varargs extends AbstractIrCodegenBoxInlineWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Varargs { + @Test public void testAllFilesPresentInVarargs() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt17653.kt") public void testKt17653() throws Exception { runTest("compiler/testData/codegen/boxInline/varargs/kt17653.kt"); } + @Test @TestMetadata("varargAndDefaultParameters.kt") public void testVarargAndDefaultParameters() throws Exception { runTest("compiler/testData/codegen/boxInline/varargs/varargAndDefaultParameters.kt"); } + @Test @TestMetadata("varargAndDefaultParameters2.kt") public void testVarargAndDefaultParameters2() throws Exception { runTest("compiler/testData/codegen/boxInline/varargs/varargAndDefaultParameters2.kt"); diff --git a/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/IrCodegenBoxWasmTestGenerated.java b/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/FirWasmCodegenBoxTestGenerated.java similarity index 90% rename from wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/IrCodegenBoxWasmTestGenerated.java rename to wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/FirWasmCodegenBoxTestGenerated.java index 2cca3949290..0d7c4143798 100644 --- a/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/IrCodegenBoxWasmTestGenerated.java +++ b/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/FirWasmCodegenBoxTestGenerated.java @@ -6,13 +6,12 @@ package org.jetbrains.kotlin.wasm.test; import com.intellij.testFramework.TestDataPath; -import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; -import org.jetbrains.kotlin.test.KotlinTestUtils; import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.utils.TransformersFunctions; import org.jetbrains.kotlin.test.TestMetadata; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; import java.io.File; import java.util.regex.Pattern; @@ -21,177 +20,173 @@ import java.util.regex.Pattern; @SuppressWarnings("all") @TestMetadata("compiler/testData/codegen/box") @TestDataPath("$PROJECT_ROOT") -@RunWith(JUnit3RunnerWithInners.class) -public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - +public class FirWasmCodegenBoxTestGenerated extends AbstractFirWasmCodegenBoxTest { + @Test public void testAllFilesPresentInBox() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true, "compileKotlinAgainstKotlin"); } + @Nested @TestMetadata("compiler/testData/codegen/box/annotations") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Annotations extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Annotations { + @Test public void testAllFilesPresentInAnnotations() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("genericAnnotations.kt") public void testGenericAnnotations() throws Exception { runTest("compiler/testData/codegen/box/annotations/genericAnnotations.kt"); } + @Test @TestMetadata("nestedAnnotation.kt") public void testNestedAnnotation() throws Exception { runTest("compiler/testData/codegen/box/annotations/nestedAnnotation.kt"); } + @Test @TestMetadata("nestedClassesInAnnotations.kt") public void testNestedClassesInAnnotations() throws Exception { runTest("compiler/testData/codegen/box/annotations/nestedClassesInAnnotations.kt"); } + @Test @TestMetadata("resolveWithLowPriorityAnnotation.kt") public void testResolveWithLowPriorityAnnotation() throws Exception { runTest("compiler/testData/codegen/box/annotations/resolveWithLowPriorityAnnotation.kt"); } + @Test @TestMetadata("selfReferentialAnnotation.kt") public void testSelfReferentialAnnotation() throws Exception { runTest("compiler/testData/codegen/box/annotations/selfReferentialAnnotation.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/annotations/annotatedLambda") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class AnnotatedLambda extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class AnnotatedLambda { + @Test public void testAllFilesPresentInAnnotatedLambda() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/annotatedLambda"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/annotations/instances") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Instances extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Instances { + @Test public void testAllFilesPresentInInstances() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/instances"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("annotationEqHc.kt") public void testAnnotationEqHc() throws Exception { runTest("compiler/testData/codegen/box/annotations/instances/annotationEqHc.kt"); } + @Test @TestMetadata("annotationFromStdlib.kt") public void testAnnotationFromStdlib() throws Exception { runTest("compiler/testData/codegen/box/annotations/instances/annotationFromStdlib.kt"); } + @Test @TestMetadata("annotationInstances.kt") public void testAnnotationInstances() throws Exception { runTest("compiler/testData/codegen/box/annotations/instances/annotationInstances.kt"); } + @Test @TestMetadata("annotationInstancesEmptyDefault.kt") public void testAnnotationInstancesEmptyDefault() throws Exception { runTest("compiler/testData/codegen/box/annotations/instances/annotationInstancesEmptyDefault.kt"); } + @Test @TestMetadata("annotationInstancesEmptyDefaultLowered.kt") public void testAnnotationInstancesEmptyDefaultLowered() throws Exception { runTest("compiler/testData/codegen/box/annotations/instances/annotationInstancesEmptyDefaultLowered.kt"); } + @Test @TestMetadata("annotationToString.kt") public void testAnnotationToString() throws Exception { runTest("compiler/testData/codegen/box/annotations/instances/annotationToString.kt"); } + @Test @TestMetadata("annotationsUnsignedTypes.kt") public void testAnnotationsUnsignedTypes() throws Exception { runTest("compiler/testData/codegen/box/annotations/instances/annotationsUnsignedTypes.kt"); } + @Test @TestMetadata("inInlineFunction.kt") public void testInInlineFunction() throws Exception { runTest("compiler/testData/codegen/box/annotations/instances/inInlineFunction.kt"); } + @Test @TestMetadata("multifileEqHc.kt") public void testMultifileEqHc() throws Exception { runTest("compiler/testData/codegen/box/annotations/instances/multifileEqHc.kt"); } + @Test @TestMetadata("multiplatformInstantiation.kt") public void testMultiplatformInstantiation() throws Exception { runTest("compiler/testData/codegen/box/annotations/instances/multiplatformInstantiation.kt"); } + @Test @TestMetadata("nestedAnnotationInstances.kt") public void testNestedAnnotationInstances() throws Exception { runTest("compiler/testData/codegen/box/annotations/instances/nestedAnnotationInstances.kt"); } + @Test @TestMetadata("varargInAnnotationParameterInstantiation.kt") public void testVarargInAnnotationParameterInstantiation() throws Exception { runTest("compiler/testData/codegen/box/annotations/instances/varargInAnnotationParameterInstantiation.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/annotations/kClassMapping") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class KClassMapping extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class KClassMapping { + @Test public void testAllFilesPresentInKClassMapping() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/kClassMapping"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/annotations/repeatable") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Repeatable extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Repeatable { + @Test public void testAllFilesPresentInRepeatable() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/repeatable"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/annotations/typeAnnotations") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TypeAnnotations extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class TypeAnnotations { + @Test public void testAllFilesPresentInTypeAnnotations() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/typeAnnotations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("checkingNotincorporatedInputTypes.kt") public void testCheckingNotincorporatedInputTypes() throws Exception { runTest("compiler/testData/codegen/box/annotations/typeAnnotations/checkingNotincorporatedInputTypes.kt"); @@ -199,637 +194,720 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/argumentOrder") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ArgumentOrder extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ArgumentOrder { + @Test public void testAllFilesPresentInArgumentOrder() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/argumentOrder"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("argumentOrderInObjectSuperCall.kt") public void testArgumentOrderInObjectSuperCall() throws Exception { runTest("compiler/testData/codegen/box/argumentOrder/argumentOrderInObjectSuperCall.kt"); } + @Test @TestMetadata("argumentOrderInSuperCall.kt") public void testArgumentOrderInSuperCall() throws Exception { runTest("compiler/testData/codegen/box/argumentOrder/argumentOrderInSuperCall.kt"); } + @Test @TestMetadata("arguments.kt") public void testArguments() throws Exception { runTest("compiler/testData/codegen/box/argumentOrder/arguments.kt"); } + @Test @TestMetadata("captured.kt") public void testCaptured() throws Exception { runTest("compiler/testData/codegen/box/argumentOrder/captured.kt"); } + @Test @TestMetadata("capturedInExtension.kt") public void testCapturedInExtension() throws Exception { runTest("compiler/testData/codegen/box/argumentOrder/capturedInExtension.kt"); } + @Test @TestMetadata("defaults.kt") public void testDefaults() throws Exception { runTest("compiler/testData/codegen/box/argumentOrder/defaults.kt"); } + @Test @TestMetadata("extension.kt") public void testExtension() throws Exception { runTest("compiler/testData/codegen/box/argumentOrder/extension.kt"); } + @Test @TestMetadata("extensionInClass.kt") public void testExtensionInClass() throws Exception { runTest("compiler/testData/codegen/box/argumentOrder/extensionInClass.kt"); } + @Test @TestMetadata("kt17691WithEnabledFeature.kt") public void testKt17691WithEnabledFeature() throws Exception { runTest("compiler/testData/codegen/box/argumentOrder/kt17691WithEnabledFeature.kt"); } + @Test @TestMetadata("kt9277.kt") public void testKt9277() throws Exception { runTest("compiler/testData/codegen/box/argumentOrder/kt9277.kt"); } + @Test @TestMetadata("lambdaMigration.kt") public void testLambdaMigration() throws Exception { runTest("compiler/testData/codegen/box/argumentOrder/lambdaMigration.kt"); } + @Test @TestMetadata("lambdaMigrationInClass.kt") public void testLambdaMigrationInClass() throws Exception { runTest("compiler/testData/codegen/box/argumentOrder/lambdaMigrationInClass.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/argumentOrder/simple.kt"); } + @Test @TestMetadata("simpleInClass.kt") public void testSimpleInClass() throws Exception { runTest("compiler/testData/codegen/box/argumentOrder/simpleInClass.kt"); } + @Test @TestMetadata("singleSideEffect.kt") public void testSingleSideEffect() throws Exception { runTest("compiler/testData/codegen/box/argumentOrder/singleSideEffect.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/arrays") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Arrays extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Arrays { + @Test public void testAllFilesPresentInArrays() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("arrayConstructorWithNonInlineLambda.kt") public void testArrayConstructorWithNonInlineLambda() throws Exception { runTest("compiler/testData/codegen/box/arrays/arrayConstructorWithNonInlineLambda.kt"); } + @Test @TestMetadata("arrayConstructorsSimple.kt") public void testArrayConstructorsSimple() throws Exception { runTest("compiler/testData/codegen/box/arrays/arrayConstructorsSimple.kt"); } + @Test @TestMetadata("arrayGetAssignMultiIndex.kt") public void testArrayGetAssignMultiIndex() throws Exception { runTest("compiler/testData/codegen/box/arrays/arrayGetAssignMultiIndex.kt"); } + @Test @TestMetadata("arrayGetMultiIndex.kt") public void testArrayGetMultiIndex() throws Exception { runTest("compiler/testData/codegen/box/arrays/arrayGetMultiIndex.kt"); } + @Test @TestMetadata("arrayInstanceOf.kt") public void testArrayInstanceOf() throws Exception { runTest("compiler/testData/codegen/box/arrays/arrayInstanceOf.kt"); } + @Test @TestMetadata("arrayPlusAssign.kt") public void testArrayPlusAssign() throws Exception { runTest("compiler/testData/codegen/box/arrays/arrayPlusAssign.kt"); } + @Test @TestMetadata("collectionAssignGetMultiIndex.kt") public void testCollectionAssignGetMultiIndex() throws Exception { runTest("compiler/testData/codegen/box/arrays/collectionAssignGetMultiIndex.kt"); } + @Test @TestMetadata("collectionGetMultiIndex.kt") public void testCollectionGetMultiIndex() throws Exception { runTest("compiler/testData/codegen/box/arrays/collectionGetMultiIndex.kt"); } + @Test @TestMetadata("constantArrayOfAny.kt") public void testConstantArrayOfAny() throws Exception { runTest("compiler/testData/codegen/box/arrays/constantArrayOfAny.kt"); } + @Test @TestMetadata("forEachBooleanArray.kt") public void testForEachBooleanArray() throws Exception { runTest("compiler/testData/codegen/box/arrays/forEachBooleanArray.kt"); } + @Test @TestMetadata("forEachByteArray.kt") public void testForEachByteArray() throws Exception { runTest("compiler/testData/codegen/box/arrays/forEachByteArray.kt"); } + @Test @TestMetadata("forEachCharArray.kt") public void testForEachCharArray() throws Exception { runTest("compiler/testData/codegen/box/arrays/forEachCharArray.kt"); } + @Test @TestMetadata("forEachDoubleArray.kt") public void testForEachDoubleArray() throws Exception { runTest("compiler/testData/codegen/box/arrays/forEachDoubleArray.kt"); } + @Test @TestMetadata("forEachFloatArray.kt") public void testForEachFloatArray() throws Exception { runTest("compiler/testData/codegen/box/arrays/forEachFloatArray.kt"); } + @Test @TestMetadata("forEachIntArray.kt") public void testForEachIntArray() throws Exception { runTest("compiler/testData/codegen/box/arrays/forEachIntArray.kt"); } + @Test @TestMetadata("forEachLongArray.kt") public void testForEachLongArray() throws Exception { runTest("compiler/testData/codegen/box/arrays/forEachLongArray.kt"); } + @Test @TestMetadata("forEachShortArray.kt") public void testForEachShortArray() throws Exception { runTest("compiler/testData/codegen/box/arrays/forEachShortArray.kt"); } + @Test @TestMetadata("genericArrayInObjectLiteralConstructor.kt") public void testGenericArrayInObjectLiteralConstructor() throws Exception { runTest("compiler/testData/codegen/box/arrays/genericArrayInObjectLiteralConstructor.kt"); } + @Test @TestMetadata("hashMap.kt") public void testHashMap() throws Exception { runTest("compiler/testData/codegen/box/arrays/hashMap.kt"); } + @Test @TestMetadata("inProjectionAsParameter.kt") public void testInProjectionAsParameter() throws Exception { runTest("compiler/testData/codegen/box/arrays/inProjectionAsParameter.kt"); } + @Test @TestMetadata("inProjectionOfArray.kt") public void testInProjectionOfArray() throws Exception { runTest("compiler/testData/codegen/box/arrays/inProjectionOfArray.kt"); } + @Test @TestMetadata("inProjectionOfList.kt") public void testInProjectionOfList() throws Exception { runTest("compiler/testData/codegen/box/arrays/inProjectionOfList.kt"); } + @Test @TestMetadata("indices.kt") public void testIndices() throws Exception { runTest("compiler/testData/codegen/box/arrays/indices.kt"); } + @Test @TestMetadata("indicesChar.kt") public void testIndicesChar() throws Exception { runTest("compiler/testData/codegen/box/arrays/indicesChar.kt"); } + @Test @TestMetadata("inlineInitializer.kt") public void testInlineInitializer() throws Exception { runTest("compiler/testData/codegen/box/arrays/inlineInitializer.kt"); } + @Test @TestMetadata("iterator.kt") public void testIterator() throws Exception { runTest("compiler/testData/codegen/box/arrays/iterator.kt"); } + @Test @TestMetadata("iteratorBooleanArray.kt") public void testIteratorBooleanArray() throws Exception { runTest("compiler/testData/codegen/box/arrays/iteratorBooleanArray.kt"); } + @Test @TestMetadata("iteratorByteArray.kt") public void testIteratorByteArray() throws Exception { runTest("compiler/testData/codegen/box/arrays/iteratorByteArray.kt"); } + @Test @TestMetadata("iteratorByteArrayNextByte.kt") public void testIteratorByteArrayNextByte() throws Exception { runTest("compiler/testData/codegen/box/arrays/iteratorByteArrayNextByte.kt"); } + @Test @TestMetadata("iteratorCharArray.kt") public void testIteratorCharArray() throws Exception { runTest("compiler/testData/codegen/box/arrays/iteratorCharArray.kt"); } + @Test @TestMetadata("iteratorDoubleArray.kt") public void testIteratorDoubleArray() throws Exception { runTest("compiler/testData/codegen/box/arrays/iteratorDoubleArray.kt"); } + @Test @TestMetadata("iteratorFloatArray.kt") public void testIteratorFloatArray() throws Exception { runTest("compiler/testData/codegen/box/arrays/iteratorFloatArray.kt"); } + @Test @TestMetadata("iteratorIntArray.kt") public void testIteratorIntArray() throws Exception { runTest("compiler/testData/codegen/box/arrays/iteratorIntArray.kt"); } + @Test @TestMetadata("iteratorLongArray.kt") public void testIteratorLongArray() throws Exception { runTest("compiler/testData/codegen/box/arrays/iteratorLongArray.kt"); } + @Test @TestMetadata("iteratorLongArrayNextLong.kt") public void testIteratorLongArrayNextLong() throws Exception { runTest("compiler/testData/codegen/box/arrays/iteratorLongArrayNextLong.kt"); } + @Test @TestMetadata("iteratorShortArray.kt") public void testIteratorShortArray() throws Exception { runTest("compiler/testData/codegen/box/arrays/iteratorShortArray.kt"); } + @Test @TestMetadata("kt1291.kt") public void testKt1291() throws Exception { runTest("compiler/testData/codegen/box/arrays/kt1291.kt"); } + @Test @TestMetadata("kt238.kt") public void testKt238() throws Exception { runTest("compiler/testData/codegen/box/arrays/kt238.kt"); } + @Test @TestMetadata("kt2997.kt") public void testKt2997() throws Exception { runTest("compiler/testData/codegen/box/arrays/kt2997.kt"); } + @Test @TestMetadata("kt33.kt") public void testKt33() throws Exception { runTest("compiler/testData/codegen/box/arrays/kt33.kt"); } + @Test @TestMetadata("kt34291_16dimensions.kt") public void testKt34291_16dimensions() throws Exception { runTest("compiler/testData/codegen/box/arrays/kt34291_16dimensions.kt"); } + @Test @TestMetadata("kt3771.kt") public void testKt3771() throws Exception { runTest("compiler/testData/codegen/box/arrays/kt3771.kt"); } + @Test @TestMetadata("kt4118.kt") public void testKt4118() throws Exception { runTest("compiler/testData/codegen/box/arrays/kt4118.kt"); } + @Test @TestMetadata("kt42932.kt") public void testKt42932() throws Exception { runTest("compiler/testData/codegen/box/arrays/kt42932.kt"); } + @Test @TestMetadata("kt4348.kt") public void testKt4348() throws Exception { runTest("compiler/testData/codegen/box/arrays/kt4348.kt"); } + @Test @TestMetadata("kt4357.kt") public void testKt4357() throws Exception { runTest("compiler/testData/codegen/box/arrays/kt4357.kt"); } + @Test @TestMetadata("kt47483.kt") public void testKt47483() throws Exception { runTest("compiler/testData/codegen/box/arrays/kt47483.kt"); } + @Test @TestMetadata("kt503.kt") public void testKt503() throws Exception { runTest("compiler/testData/codegen/box/arrays/kt503.kt"); } + @Test @TestMetadata("kt55984.kt") public void testKt55984() throws Exception { runTest("compiler/testData/codegen/box/arrays/kt55984.kt"); } + @Test @TestMetadata("kt594.kt") public void testKt594() throws Exception { runTest("compiler/testData/codegen/box/arrays/kt594.kt"); } + @Test @TestMetadata("kt7009.kt") public void testKt7009() throws Exception { runTest("compiler/testData/codegen/box/arrays/kt7009.kt"); } + @Test @TestMetadata("kt7288.kt") public void testKt7288() throws Exception { runTest("compiler/testData/codegen/box/arrays/kt7288.kt"); } + @Test @TestMetadata("kt779.kt") public void testKt779() throws Exception { runTest("compiler/testData/codegen/box/arrays/kt779.kt"); } + @Test @TestMetadata("kt945.kt") public void testKt945() throws Exception { runTest("compiler/testData/codegen/box/arrays/kt945.kt"); } + @Test @TestMetadata("kt950.kt") public void testKt950() throws Exception { runTest("compiler/testData/codegen/box/arrays/kt950.kt"); } + @Test @TestMetadata("longAsIndex.kt") public void testLongAsIndex() throws Exception { runTest("compiler/testData/codegen/box/arrays/longAsIndex.kt"); } + @Test @TestMetadata("multiArrayConstructors.kt") public void testMultiArrayConstructors() throws Exception { runTest("compiler/testData/codegen/box/arrays/multiArrayConstructors.kt"); } + @Test @TestMetadata("nonLocalReturnArrayConstructor.kt") public void testNonLocalReturnArrayConstructor() throws Exception { runTest("compiler/testData/codegen/box/arrays/nonLocalReturnArrayConstructor.kt"); } + @Test @TestMetadata("nonNullArray.kt") public void testNonNullArray() throws Exception { runTest("compiler/testData/codegen/box/arrays/nonNullArray.kt"); } + @Test @TestMetadata("primitiveArrays.kt") public void testPrimitiveArrays() throws Exception { runTest("compiler/testData/codegen/box/arrays/primitiveArrays.kt"); } + @Test @TestMetadata("stdlib.kt") public void testStdlib() throws Exception { runTest("compiler/testData/codegen/box/arrays/stdlib.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/arrays/arraysOfInlineClass") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ArraysOfInlineClass extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ArraysOfInlineClass { + @Test @TestMetadata("accessArrayOfInlineClass.kt") public void testAccessArrayOfInlineClass() throws Exception { runTest("compiler/testData/codegen/box/arrays/arraysOfInlineClass/accessArrayOfInlineClass.kt"); } + @Test @TestMetadata("accessArrayOfUnsigned.kt") public void testAccessArrayOfUnsigned() throws Exception { runTest("compiler/testData/codegen/box/arrays/arraysOfInlineClass/accessArrayOfUnsigned.kt"); } + @Test public void testAllFilesPresentInArraysOfInlineClass() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/arraysOfInlineClass"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("arrayOfInlineClassOfArrayOfInlineClass.kt") public void testArrayOfInlineClassOfArrayOfInlineClass() throws Exception { runTest("compiler/testData/codegen/box/arrays/arraysOfInlineClass/arrayOfInlineClassOfArrayOfInlineClass.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/arrays/forInReversed") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ForInReversed extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ForInReversed { + @Test public void testAllFilesPresentInForInReversed() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/forInReversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("reversedArrayOriginalUpdatedInLoopBody.kt") public void testReversedArrayOriginalUpdatedInLoopBody() throws Exception { runTest("compiler/testData/codegen/box/arrays/forInReversed/reversedArrayOriginalUpdatedInLoopBody.kt"); } + @Test @TestMetadata("reversedArrayReversedArrayOriginalUpdatedInLoopBody.kt") public void testReversedArrayReversedArrayOriginalUpdatedInLoopBody() throws Exception { runTest("compiler/testData/codegen/box/arrays/forInReversed/reversedArrayReversedArrayOriginalUpdatedInLoopBody.kt"); } + @Test @TestMetadata("reversedOriginalUpdatedInLoopBody.kt") public void testReversedOriginalUpdatedInLoopBody() throws Exception { runTest("compiler/testData/codegen/box/arrays/forInReversed/reversedOriginalUpdatedInLoopBody.kt"); } + @Test @TestMetadata("reversedReversedOriginalUpdatedInLoopBody.kt") public void testReversedReversedOriginalUpdatedInLoopBody() throws Exception { runTest("compiler/testData/codegen/box/arrays/forInReversed/reversedReversedOriginalUpdatedInLoopBody.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/arrays/forInUnsignedArray") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ForInUnsignedArray extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ForInUnsignedArray { + @Test public void testAllFilesPresentInForInUnsignedArray() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/forInUnsignedArray"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("forInUnsignedArray.kt") public void testForInUnsignedArray() throws Exception { runTest("compiler/testData/codegen/box/arrays/forInUnsignedArray/forInUnsignedArray.kt"); } + @Test @TestMetadata("forInUnsignedArrayIndices.kt") public void testForInUnsignedArrayIndices() throws Exception { runTest("compiler/testData/codegen/box/arrays/forInUnsignedArray/forInUnsignedArrayIndices.kt"); } + @Test @TestMetadata("forInUnsignedArrayIndicesReversed.kt") public void testForInUnsignedArrayIndicesReversed() throws Exception { runTest("compiler/testData/codegen/box/arrays/forInUnsignedArray/forInUnsignedArrayIndicesReversed.kt"); } + @Test @TestMetadata("forInUnsignedArrayReversed.kt") public void testForInUnsignedArrayReversed() throws Exception { runTest("compiler/testData/codegen/box/arrays/forInUnsignedArray/forInUnsignedArrayReversed.kt"); } + @Test @TestMetadata("forInUnsignedArrayWithIndex.kt") public void testForInUnsignedArrayWithIndex() throws Exception { runTest("compiler/testData/codegen/box/arrays/forInUnsignedArray/forInUnsignedArrayWithIndex.kt"); } + @Test @TestMetadata("forInUnsignedArrayWithIndexNoElementVar.kt") public void testForInUnsignedArrayWithIndexNoElementVar() throws Exception { runTest("compiler/testData/codegen/box/arrays/forInUnsignedArray/forInUnsignedArrayWithIndexNoElementVar.kt"); } + @Test @TestMetadata("forInUnsignedArrayWithIndexNoIndexVar.kt") public void testForInUnsignedArrayWithIndexNoIndexVar() throws Exception { runTest("compiler/testData/codegen/box/arrays/forInUnsignedArray/forInUnsignedArrayWithIndexNoIndexVar.kt"); } + @Test @TestMetadata("forInUnsignedArrayWithIndexReversed.kt") public void testForInUnsignedArrayWithIndexReversed() throws Exception { runTest("compiler/testData/codegen/box/arrays/forInUnsignedArray/forInUnsignedArrayWithIndexReversed.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/arrays/multiDecl") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class MultiDecl extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class MultiDecl { + @Test public void testAllFilesPresentInMultiDecl() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt15560.kt") public void testKt15560() throws Exception { runTest("compiler/testData/codegen/box/arrays/multiDecl/kt15560.kt"); } + @Test @TestMetadata("kt15568.kt") public void testKt15568() throws Exception { runTest("compiler/testData/codegen/box/arrays/multiDecl/kt15568.kt"); } + @Test @TestMetadata("kt15575.kt") public void testKt15575() throws Exception { runTest("compiler/testData/codegen/box/arrays/multiDecl/kt15575.kt"); } + @Test @TestMetadata("MultiDeclFor.kt") public void testMultiDeclFor() throws Exception { runTest("compiler/testData/codegen/box/arrays/multiDecl/MultiDeclFor.kt"); } + @Test @TestMetadata("MultiDeclForComponentExtensions.kt") public void testMultiDeclForComponentExtensions() throws Exception { runTest("compiler/testData/codegen/box/arrays/multiDecl/MultiDeclForComponentExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensions.kt") public void testMultiDeclForComponentMemberExtensions() throws Exception { runTest("compiler/testData/codegen/box/arrays/multiDecl/MultiDeclForComponentMemberExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { runTest("compiler/testData/codegen/box/arrays/multiDecl/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); } + @Test @TestMetadata("MultiDeclForValCaptured.kt") public void testMultiDeclForValCaptured() throws Exception { runTest("compiler/testData/codegen/box/arrays/multiDecl/MultiDeclForValCaptured.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/arrays/multiDecl/int") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Int extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Int { + @Test public void testAllFilesPresentInInt() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/int"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("MultiDeclForComponentExtensions.kt") public void testMultiDeclForComponentExtensions() throws Exception { runTest("compiler/testData/codegen/box/arrays/multiDecl/int/MultiDeclForComponentExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentExtensionsValCaptured.kt") public void testMultiDeclForComponentExtensionsValCaptured() throws Exception { runTest("compiler/testData/codegen/box/arrays/multiDecl/int/MultiDeclForComponentExtensionsValCaptured.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensions.kt") public void testMultiDeclForComponentMemberExtensions() throws Exception { runTest("compiler/testData/codegen/box/arrays/multiDecl/int/MultiDeclForComponentMemberExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { runTest("compiler/testData/codegen/box/arrays/multiDecl/int/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/arrays/multiDecl/long") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Long extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Long { + @Test public void testAllFilesPresentInLong() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/long"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("MultiDeclForComponentExtensions.kt") public void testMultiDeclForComponentExtensions() throws Exception { runTest("compiler/testData/codegen/box/arrays/multiDecl/long/MultiDeclForComponentExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentExtensionsValCaptured.kt") public void testMultiDeclForComponentExtensionsValCaptured() throws Exception { runTest("compiler/testData/codegen/box/arrays/multiDecl/long/MultiDeclForComponentExtensionsValCaptured.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensions.kt") public void testMultiDeclForComponentMemberExtensions() throws Exception { runTest("compiler/testData/codegen/box/arrays/multiDecl/long/MultiDeclForComponentMemberExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { runTest("compiler/testData/codegen/box/arrays/multiDecl/long/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); @@ -838,757 +916,875 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/assert") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Assert extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Assert { + @Test public void testAllFilesPresentInAssert() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("alwaysDisable.kt") public void testAlwaysDisable() throws Exception { runTest("compiler/testData/codegen/box/assert/alwaysDisable.kt"); } + @Test @TestMetadata("alwaysEnable.kt") public void testAlwaysEnable() throws Exception { runTest("compiler/testData/codegen/box/assert/alwaysEnable.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/assert/jvm") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Jvm extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Jvm { + @Test public void testAllFilesPresentInJvm() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert/jvm"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/binaryOp") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class BinaryOp extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class BinaryOp { + @Test public void testAllFilesPresentInBinaryOp() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/binaryOp"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("bitwiseOp.kt") public void testBitwiseOp() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/bitwiseOp.kt"); } + @Test @TestMetadata("bitwiseOpAny.kt") public void testBitwiseOpAny() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/bitwiseOpAny.kt"); } + @Test @TestMetadata("bitwiseOpNullable.kt") public void testBitwiseOpNullable() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/bitwiseOpNullable.kt"); } + @Test @TestMetadata("call.kt") public void testCall() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/call.kt"); } + @Test @TestMetadata("callAny.kt") public void testCallAny() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/callAny.kt"); } + @Test @TestMetadata("callNullable.kt") public void testCallNullable() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/callNullable.kt"); } + @Test @TestMetadata("compareBoxedChars.kt") public void testCompareBoxedChars() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/compareBoxedChars.kt"); } + @Test @TestMetadata("divisionByZero.kt") public void testDivisionByZero() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/divisionByZero.kt"); } + @Test @TestMetadata("eqNullableDoubles.kt") public void testEqNullableDoubles() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/eqNullableDoubles.kt"); } + @Test @TestMetadata("eqNullableDoublesToInt.kt") public void testEqNullableDoublesToInt() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/eqNullableDoublesToInt.kt"); } + @Test @TestMetadata("eqNullableDoublesToIntWithTP.kt") public void testEqNullableDoublesToIntWithTP() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/eqNullableDoublesToIntWithTP.kt"); } + @Test @TestMetadata("eqNullableDoublesWithTP.kt") public void testEqNullableDoublesWithTP() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/eqNullableDoublesWithTP.kt"); } + @Test @TestMetadata("eqNullableShortToShort.kt") public void testEqNullableShortToShort() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/eqNullableShortToShort.kt"); } + @Test @TestMetadata("eqNullableToPrimitiveWithSideEffects.kt") public void testEqNullableToPrimitiveWithSideEffects() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/eqNullableToPrimitiveWithSideEffects.kt"); } + @Test @TestMetadata("intrinsic.kt") public void testIntrinsic() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/intrinsic.kt"); } + @Test @TestMetadata("intrinsicAny.kt") public void testIntrinsicAny() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/intrinsicAny.kt"); } + @Test @TestMetadata("intrinsicNullable.kt") public void testIntrinsicNullable() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/intrinsicNullable.kt"); } + @Test @TestMetadata("kt11163.kt") public void testKt11163() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/kt11163.kt"); } + @Test @TestMetadata("kt11163_properIeee754comparisons.kt") public void testKt11163_properIeee754comparisons() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/kt11163_properIeee754comparisons.kt"); } + @Test @TestMetadata("kt23030_properIeee754comparisons.kt") public void testKt23030_properIeee754comparisons() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/kt23030_properIeee754comparisons.kt"); } + @Test @TestMetadata("kt44402.kt") public void testKt44402() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/kt44402.kt"); } + @Test @TestMetadata("kt6747_identityEquals.kt") public void testKt6747_identityEquals() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/kt6747_identityEquals.kt"); } + @Test @TestMetadata("overflowChar.kt") public void testOverflowChar() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/overflowChar.kt"); } + @Test @TestMetadata("overflowInt.kt") public void testOverflowInt() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/overflowInt.kt"); } + @Test @TestMetadata("overflowLong.kt") public void testOverflowLong() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/overflowLong.kt"); } + @Test @TestMetadata("primitiveEqualsSafeCall.kt") public void testPrimitiveEqualsSafeCall() throws Exception { runTest("compiler/testData/codegen/box/binaryOp/primitiveEqualsSafeCall.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/boxingOptimization") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class BoxingOptimization extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class BoxingOptimization { + @Test public void testAllFilesPresentInBoxingOptimization() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/boxingOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("boxedIntegersCmp.kt") public void testBoxedIntegersCmp() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/boxedIntegersCmp.kt"); } + @Test @TestMetadata("boxedPrimitivesAreEqual.kt") public void testBoxedPrimitivesAreEqual() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/boxedPrimitivesAreEqual.kt"); } + @Test @TestMetadata("boxedRealsCmp.kt") public void testBoxedRealsCmp() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/boxedRealsCmp.kt"); } + @Test @TestMetadata("casts.kt") public void testCasts() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/casts.kt"); } + @Test @TestMetadata("checkcastAndInstanceOf2.kt") public void testCheckcastAndInstanceOf2() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/checkcastAndInstanceOf2.kt"); } + @Test @TestMetadata("explicitEqualsOnDouble.kt") public void testExplicitEqualsOnDouble() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/explicitEqualsOnDouble.kt"); } + @Test @TestMetadata("fold.kt") public void testFold() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/fold.kt"); } + @Test @TestMetadata("foldRange.kt") public void testFoldRange() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/foldRange.kt"); } + @Test @TestMetadata("intCompareTo.kt") public void testIntCompareTo() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/intCompareTo.kt"); } + @Test @TestMetadata("kt15871.kt") public void testKt15871() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/kt15871.kt"); } + @Test @TestMetadata("kt19767.kt") public void testKt19767() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/kt19767.kt"); } + @Test @TestMetadata("kt19767_2.kt") public void testKt19767_2() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/kt19767_2.kt"); } + @Test @TestMetadata("kt19767_chain.kt") public void testKt19767_chain() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/kt19767_chain.kt"); } + @Test @TestMetadata("kt46859.kt") public void testKt46859() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/kt46859.kt"); } + @Test @TestMetadata("kt48394.kt") public void testKt48394() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/kt48394.kt"); } + @Test @TestMetadata("kt49092a.kt") public void testKt49092a() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/kt49092a.kt"); } + @Test @TestMetadata("kt49092b.kt") public void testKt49092b() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/kt49092b.kt"); } + @Test @TestMetadata("kt49092c.kt") public void testKt49092c() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/kt49092c.kt"); } + @Test @TestMetadata("kt49092d.kt") public void testKt49092d() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/kt49092d.kt"); } + @Test @TestMetadata("kt49092e.kt") public void testKt49092e() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/kt49092e.kt"); } + @Test @TestMetadata("kt49092f.kt") public void testKt49092f() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/kt49092f.kt"); } + @Test @TestMetadata("kt49548.kt") public void testKt49548() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/kt49548.kt"); } + @Test @TestMetadata("kt49548a.kt") public void testKt49548a() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/kt49548a.kt"); } + @Test @TestMetadata("kt5493.kt") public void testKt5493() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/kt5493.kt"); } + @Test @TestMetadata("kt5588.kt") public void testKt5588() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/kt5588.kt"); } + @Test @TestMetadata("kt5844.kt") public void testKt5844() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/kt5844.kt"); } + @Test @TestMetadata("kt6842.kt") public void testKt6842() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/kt6842.kt"); } + @Test @TestMetadata("maxMinByOrNull.kt") public void testMaxMinByOrNull() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/maxMinByOrNull.kt"); } + @Test @TestMetadata("nullCheck.kt") public void testNullCheck() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/nullCheck.kt"); } + @Test @TestMetadata("progressions.kt") public void testProgressions() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/progressions.kt"); } + @Test @TestMetadata("safeCallWithElvis.kt") public void testSafeCallWithElvis() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/safeCallWithElvis.kt"); } + @Test @TestMetadata("safeCallWithElvisMultipleFiles.kt") public void testSafeCallWithElvisMultipleFiles() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/safeCallWithElvisMultipleFiles.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/simple.kt"); } + @Test @TestMetadata("simpleUninitializedMerge.kt") public void testSimpleUninitializedMerge() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/simpleUninitializedMerge.kt"); } + @Test @TestMetadata("taintedValues.kt") public void testTaintedValues() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/taintedValues.kt"); } + @Test @TestMetadata("taintedValuesBox.kt") public void testTaintedValuesBox() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/taintedValuesBox.kt"); } + @Test @TestMetadata("unsafeRemoving.kt") public void testUnsafeRemoving() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/unsafeRemoving.kt"); } + @Test @TestMetadata("unsignedArrayForEach.kt") public void testUnsignedArrayForEach() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/unsignedArrayForEach.kt"); } + @Test @TestMetadata("variables.kt") public void testVariables() throws Exception { runTest("compiler/testData/codegen/box/boxingOptimization/variables.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/bridges") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Bridges extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Bridges { + @Test @TestMetadata("abstractOverrideBridge.kt") public void testAbstractOverrideBridge() throws Exception { runTest("compiler/testData/codegen/box/bridges/abstractOverrideBridge.kt"); } + @Test public void testAllFilesPresentInBridges() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("complexMultiInheritance.kt") public void testComplexMultiInheritance() throws Exception { runTest("compiler/testData/codegen/box/bridges/complexMultiInheritance.kt"); } + @Test @TestMetadata("complexTraitImpl.kt") public void testComplexTraitImpl() throws Exception { runTest("compiler/testData/codegen/box/bridges/complexTraitImpl.kt"); } + @Test @TestMetadata("covariantGenericDiamond.kt") public void testCovariantGenericDiamond() throws Exception { runTest("compiler/testData/codegen/box/bridges/covariantGenericDiamond.kt"); } + @Test @TestMetadata("delegation.kt") public void testDelegation() throws Exception { runTest("compiler/testData/codegen/box/bridges/delegation.kt"); } + @Test @TestMetadata("delegationComplex.kt") public void testDelegationComplex() throws Exception { runTest("compiler/testData/codegen/box/bridges/delegationComplex.kt"); } + @Test @TestMetadata("delegationComplexWithList.kt") public void testDelegationComplexWithList() throws Exception { runTest("compiler/testData/codegen/box/bridges/delegationComplexWithList.kt"); } + @Test @TestMetadata("delegationProperty.kt") public void testDelegationProperty() throws Exception { runTest("compiler/testData/codegen/box/bridges/delegationProperty.kt"); } + @Test @TestMetadata("diamond.kt") public void testDiamond() throws Exception { runTest("compiler/testData/codegen/box/bridges/diamond.kt"); } + @Test @TestMetadata("fakeCovariantOverride.kt") public void testFakeCovariantOverride() throws Exception { runTest("compiler/testData/codegen/box/bridges/fakeCovariantOverride.kt"); } + @Test @TestMetadata("fakeGenericCovariantOverride.kt") public void testFakeGenericCovariantOverride() throws Exception { runTest("compiler/testData/codegen/box/bridges/fakeGenericCovariantOverride.kt"); } + @Test @TestMetadata("fakeGenericCovariantOverrideWithDelegation.kt") public void testFakeGenericCovariantOverrideWithDelegation() throws Exception { runTest("compiler/testData/codegen/box/bridges/fakeGenericCovariantOverrideWithDelegation.kt"); } + @Test @TestMetadata("fakeOverrideFromInterfaceThroughIntermediateClass.kt") public void testFakeOverrideFromInterfaceThroughIntermediateClass() throws Exception { runTest("compiler/testData/codegen/box/bridges/fakeOverrideFromInterfaceThroughIntermediateClass.kt"); } + @Test @TestMetadata("fakeOverrideMultiFile.kt") public void testFakeOverrideMultiFile() throws Exception { runTest("compiler/testData/codegen/box/bridges/fakeOverrideMultiFile.kt"); } + @Test @TestMetadata("fakeOverrideOfTraitImpl.kt") public void testFakeOverrideOfTraitImpl() throws Exception { runTest("compiler/testData/codegen/box/bridges/fakeOverrideOfTraitImpl.kt"); } + @Test @TestMetadata("fakeOverrideThroughGenericSuperclass.kt") public void testFakeOverrideThroughGenericSuperclass() throws Exception { runTest("compiler/testData/codegen/box/bridges/fakeOverrideThroughGenericSuperclass.kt"); } + @Test @TestMetadata("fakeOverrideWithSeveralSuperDeclarations.kt") public void testFakeOverrideWithSeveralSuperDeclarations() throws Exception { runTest("compiler/testData/codegen/box/bridges/fakeOverrideWithSeveralSuperDeclarations.kt"); } + @Test @TestMetadata("fakeOverrideWithSynthesizedImplementation.kt") public void testFakeOverrideWithSynthesizedImplementation() throws Exception { runTest("compiler/testData/codegen/box/bridges/fakeOverrideWithSynthesizedImplementation.kt"); } + @Test @TestMetadata("genericProperty.kt") public void testGenericProperty() throws Exception { runTest("compiler/testData/codegen/box/bridges/genericProperty.kt"); } + @Test @TestMetadata("innerClassTypeParameters.kt") public void testInnerClassTypeParameters() throws Exception { runTest("compiler/testData/codegen/box/bridges/innerClassTypeParameters.kt"); } + @Test @TestMetadata("kt12416.kt") public void testKt12416() throws Exception { runTest("compiler/testData/codegen/box/bridges/kt12416.kt"); } + @Test @TestMetadata("kt1939.kt") public void testKt1939() throws Exception { runTest("compiler/testData/codegen/box/bridges/kt1939.kt"); } + @Test @TestMetadata("kt1959.kt") public void testKt1959() throws Exception { runTest("compiler/testData/codegen/box/bridges/kt1959.kt"); } + @Test @TestMetadata("kt2498.kt") public void testKt2498() throws Exception { runTest("compiler/testData/codegen/box/bridges/kt2498.kt"); } + @Test @TestMetadata("kt2702.kt") public void testKt2702() throws Exception { runTest("compiler/testData/codegen/box/bridges/kt2702.kt"); } + @Test @TestMetadata("kt2833.kt") public void testKt2833() throws Exception { runTest("compiler/testData/codegen/box/bridges/kt2833.kt"); } + @Test @TestMetadata("kt2920.kt") public void testKt2920() throws Exception { runTest("compiler/testData/codegen/box/bridges/kt2920.kt"); } + @Test @TestMetadata("kt318.kt") public void testKt318() throws Exception { runTest("compiler/testData/codegen/box/bridges/kt318.kt"); } + @Test @TestMetadata("kt42137.kt") public void testKt42137() throws Exception { runTest("compiler/testData/codegen/box/bridges/kt42137.kt"); } + @Test @TestMetadata("kt46389.kt") public void testKt46389() throws Exception { runTest("compiler/testData/codegen/box/bridges/kt46389.kt"); } + @Test @TestMetadata("kt46389_jvmDefault.kt") public void testKt46389_jvmDefault() throws Exception { runTest("compiler/testData/codegen/box/bridges/kt46389_jvmDefault.kt"); } + @Test @TestMetadata("longChainOneBridge.kt") public void testLongChainOneBridge() throws Exception { runTest("compiler/testData/codegen/box/bridges/longChainOneBridge.kt"); } + @Test @TestMetadata("manyTypeArgumentsSubstitutedSuccessively.kt") public void testManyTypeArgumentsSubstitutedSuccessively() throws Exception { runTest("compiler/testData/codegen/box/bridges/manyTypeArgumentsSubstitutedSuccessively.kt"); } + @Test @TestMetadata("methodFromTrait.kt") public void testMethodFromTrait() throws Exception { runTest("compiler/testData/codegen/box/bridges/methodFromTrait.kt"); } + @Test @TestMetadata("methodWithDefaultParameter.kt") public void testMethodWithDefaultParameter() throws Exception { runTest("compiler/testData/codegen/box/bridges/methodWithDefaultParameter.kt"); } + @Test @TestMetadata("nestedClassTypeParameters.kt") public void testNestedClassTypeParameters() throws Exception { runTest("compiler/testData/codegen/box/bridges/nestedClassTypeParameters.kt"); } + @Test @TestMetadata("noBridgeOnMutableCollectionInheritance.kt") public void testNoBridgeOnMutableCollectionInheritance() throws Exception { runTest("compiler/testData/codegen/box/bridges/noBridgeOnMutableCollectionInheritance.kt"); } + @Test @TestMetadata("overrideAbstractProperty.kt") public void testOverrideAbstractProperty() throws Exception { runTest("compiler/testData/codegen/box/bridges/overrideAbstractProperty.kt"); } + @Test @TestMetadata("overrideReturnType.kt") public void testOverrideReturnType() throws Exception { runTest("compiler/testData/codegen/box/bridges/overrideReturnType.kt"); } + @Test @TestMetadata("overrideWithValueClassReturn.kt") public void testOverrideWithValueClassReturn() throws Exception { runTest("compiler/testData/codegen/box/bridges/overrideWithValueClassReturn.kt"); } + @Test @TestMetadata("propertyAccessorsWithoutBody.kt") public void testPropertyAccessorsWithoutBody() throws Exception { runTest("compiler/testData/codegen/box/bridges/propertyAccessorsWithoutBody.kt"); } + @Test @TestMetadata("propertyDiamond.kt") public void testPropertyDiamond() throws Exception { runTest("compiler/testData/codegen/box/bridges/propertyDiamond.kt"); } + @Test @TestMetadata("propertyDiamondFakeOverride.kt") public void testPropertyDiamondFakeOverride() throws Exception { runTest("compiler/testData/codegen/box/bridges/propertyDiamondFakeOverride.kt"); } + @Test @TestMetadata("propertyInConstructor.kt") public void testPropertyInConstructor() throws Exception { runTest("compiler/testData/codegen/box/bridges/propertyInConstructor.kt"); } + @Test @TestMetadata("propertySetter.kt") public void testPropertySetter() throws Exception { runTest("compiler/testData/codegen/box/bridges/propertySetter.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/bridges/simple.kt"); } + @Test @TestMetadata("simpleEnum.kt") public void testSimpleEnum() throws Exception { runTest("compiler/testData/codegen/box/bridges/simpleEnum.kt"); } + @Test @TestMetadata("simpleGenericMethod.kt") public void testSimpleGenericMethod() throws Exception { runTest("compiler/testData/codegen/box/bridges/simpleGenericMethod.kt"); } + @Test @TestMetadata("simpleObject.kt") public void testSimpleObject() throws Exception { runTest("compiler/testData/codegen/box/bridges/simpleObject.kt"); } + @Test @TestMetadata("simpleReturnType.kt") public void testSimpleReturnType() throws Exception { runTest("compiler/testData/codegen/box/bridges/simpleReturnType.kt"); } + @Test @TestMetadata("simpleTraitImpl.kt") public void testSimpleTraitImpl() throws Exception { runTest("compiler/testData/codegen/box/bridges/simpleTraitImpl.kt"); } + @Test @TestMetadata("simpleUpperBound.kt") public void testSimpleUpperBound() throws Exception { runTest("compiler/testData/codegen/box/bridges/simpleUpperBound.kt"); } + @Test @TestMetadata("strListContains.kt") public void testStrListContains() throws Exception { runTest("compiler/testData/codegen/box/bridges/strListContains.kt"); } + @Test @TestMetadata("traitImplInheritsTraitImpl.kt") public void testTraitImplInheritsTraitImpl() throws Exception { runTest("compiler/testData/codegen/box/bridges/traitImplInheritsTraitImpl.kt"); } + @Test @TestMetadata("twoParentsWithDifferentMethodsTwoBridges.kt") public void testTwoParentsWithDifferentMethodsTwoBridges() throws Exception { runTest("compiler/testData/codegen/box/bridges/twoParentsWithDifferentMethodsTwoBridges.kt"); } + @Test @TestMetadata("twoParentsWithDifferentMethodsTwoBridges2.kt") public void testTwoParentsWithDifferentMethodsTwoBridges2() throws Exception { runTest("compiler/testData/codegen/box/bridges/twoParentsWithDifferentMethodsTwoBridges2.kt"); } + @Test @TestMetadata("twoParentsWithTheSameMethodOneBridge.kt") public void testTwoParentsWithTheSameMethodOneBridge() throws Exception { runTest("compiler/testData/codegen/box/bridges/twoParentsWithTheSameMethodOneBridge.kt"); } + @Test @TestMetadata("typeParameterInExtensionReceiver.kt") public void testTypeParameterInExtensionReceiver() throws Exception { runTest("compiler/testData/codegen/box/bridges/typeParameterInExtensionReceiver.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/bridges/substitutionInSuperClass") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SubstitutionInSuperClass extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class SubstitutionInSuperClass { + @Test @TestMetadata("abstractFun.kt") public void testAbstractFun() throws Exception { runTest("compiler/testData/codegen/box/bridges/substitutionInSuperClass/abstractFun.kt"); } + @Test public void testAllFilesPresentInSubstitutionInSuperClass() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges/substitutionInSuperClass"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("boundedTypeArguments.kt") public void testBoundedTypeArguments() throws Exception { runTest("compiler/testData/codegen/box/bridges/substitutionInSuperClass/boundedTypeArguments.kt"); } + @Test @TestMetadata("delegation.kt") public void testDelegation() throws Exception { runTest("compiler/testData/codegen/box/bridges/substitutionInSuperClass/delegation.kt"); } + @Test @TestMetadata("differentErasureInSuperClass.kt") public void testDifferentErasureInSuperClass() throws Exception { runTest("compiler/testData/codegen/box/bridges/substitutionInSuperClass/differentErasureInSuperClass.kt"); } + @Test @TestMetadata("differentErasureInSuperClassComplex.kt") public void testDifferentErasureInSuperClassComplex() throws Exception { runTest("compiler/testData/codegen/box/bridges/substitutionInSuperClass/differentErasureInSuperClassComplex.kt"); } + @Test @TestMetadata("enum.kt") public void testEnum() throws Exception { runTest("compiler/testData/codegen/box/bridges/substitutionInSuperClass/enum.kt"); } + @Test @TestMetadata("genericMethod.kt") public void testGenericMethod() throws Exception { runTest("compiler/testData/codegen/box/bridges/substitutionInSuperClass/genericMethod.kt"); } + @Test @TestMetadata("object.kt") public void testObject() throws Exception { runTest("compiler/testData/codegen/box/bridges/substitutionInSuperClass/object.kt"); } + @Test @TestMetadata("property.kt") public void testProperty() throws Exception { runTest("compiler/testData/codegen/box/bridges/substitutionInSuperClass/property.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/bridges/substitutionInSuperClass/simple.kt"); } + @Test @TestMetadata("upperBound.kt") public void testUpperBound() throws Exception { runTest("compiler/testData/codegen/box/bridges/substitutionInSuperClass/upperBound.kt"); @@ -1596,482 +1792,534 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/builtinStubMethods") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class BuiltinStubMethods extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class BuiltinStubMethods { + @Test public void testAllFilesPresentInBuiltinStubMethods() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("customReadOnlyIterator.kt") public void testCustomReadOnlyIterator() throws Exception { runTest("compiler/testData/codegen/box/builtinStubMethods/customReadOnlyIterator.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/builtinStubMethods/bridgesForStubs") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class BridgesForStubs extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class BridgesForStubs { + @Test public void testAllFilesPresentInBridgesForStubs() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/bridgesForStubs"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/builtinStubMethods/extendJavaClasses") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ExtendJavaClasses extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ExtendJavaClasses { + @Test @TestMetadata("abstractSet.kt") public void testAbstractSet() throws Exception { runTest("compiler/testData/codegen/box/builtinStubMethods/extendJavaClasses/abstractSet.kt"); } + @Test public void testAllFilesPresentInExtendJavaClasses() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/extendJavaClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("arrayList.kt") public void testArrayList() throws Exception { runTest("compiler/testData/codegen/box/builtinStubMethods/extendJavaClasses/arrayList.kt"); } + @Test @TestMetadata("extendArrayListThroughKotlin.kt") public void testExtendArrayListThroughKotlin() throws Exception { runTest("compiler/testData/codegen/box/builtinStubMethods/extendJavaClasses/extendArrayListThroughKotlin.kt"); } + @Test @TestMetadata("hashMap.kt") public void testHashMap() throws Exception { runTest("compiler/testData/codegen/box/builtinStubMethods/extendJavaClasses/hashMap.kt"); } + @Test @TestMetadata("hashSet.kt") public void testHashSet() throws Exception { runTest("compiler/testData/codegen/box/builtinStubMethods/extendJavaClasses/hashSet.kt"); } + @Test @TestMetadata("overrideAbstractSetMethod.kt") public void testOverrideAbstractSetMethod() throws Exception { runTest("compiler/testData/codegen/box/builtinStubMethods/extendJavaClasses/overrideAbstractSetMethod.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/builtinStubMethods/mapGetOrDefault") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class MapGetOrDefault extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class MapGetOrDefault { + @Test public void testAllFilesPresentInMapGetOrDefault() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapGetOrDefault"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/builtinStubMethods/mapRemove") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class MapRemove extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class MapRemove { + @Test public void testAllFilesPresentInMapRemove() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapRemove"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/callableReference") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class CallableReference extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class CallableReference { + @Test public void testAllFilesPresentInCallableReference() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("arrayConstructor.kt") public void testArrayConstructor() throws Exception { runTest("compiler/testData/codegen/box/callableReference/arrayConstructor.kt"); } + @Test @TestMetadata("arrayConstructorArgument.kt") public void testArrayConstructorArgument() throws Exception { runTest("compiler/testData/codegen/box/callableReference/arrayConstructorArgument.kt"); } + @Test @TestMetadata("arrayOf.kt") public void testArrayOf() throws Exception { runTest("compiler/testData/codegen/box/callableReference/arrayOf.kt"); } + @Test @TestMetadata("callableReferenceOfCompanionConst.kt") public void testCallableReferenceOfCompanionConst() throws Exception { runTest("compiler/testData/codegen/box/callableReference/callableReferenceOfCompanionConst.kt"); } + @Test @TestMetadata("callableReferenceOfCompanionMethod.kt") public void testCallableReferenceOfCompanionMethod() throws Exception { runTest("compiler/testData/codegen/box/callableReference/callableReferenceOfCompanionMethod.kt"); } + @Test @TestMetadata("callableReferenceOfCompanionProperty.kt") public void testCallableReferenceOfCompanionProperty() throws Exception { runTest("compiler/testData/codegen/box/callableReference/callableReferenceOfCompanionProperty.kt"); } + @Test @TestMetadata("callableReferenceOfKotlinNestedClass.kt") public void testCallableReferenceOfKotlinNestedClass() throws Exception { runTest("compiler/testData/codegen/box/callableReference/callableReferenceOfKotlinNestedClass.kt"); } + @Test @TestMetadata("callableReferenceOfObjectMethod.kt") public void testCallableReferenceOfObjectMethod() throws Exception { runTest("compiler/testData/codegen/box/callableReference/callableReferenceOfObjectMethod.kt"); } + @Test @TestMetadata("charArrayOf.kt") public void testCharArrayOf() throws Exception { runTest("compiler/testData/codegen/box/callableReference/charArrayOf.kt"); } + @Test @TestMetadata("genericConstructorReference.kt") public void testGenericConstructorReference() throws Exception { runTest("compiler/testData/codegen/box/callableReference/genericConstructorReference.kt"); } + @Test @TestMetadata("genericLocalClassConstructorReference.kt") public void testGenericLocalClassConstructorReference() throws Exception { runTest("compiler/testData/codegen/box/callableReference/genericLocalClassConstructorReference.kt"); } + @Test @TestMetadata("inlineArrayConstructors.kt") public void testInlineArrayConstructors() throws Exception { runTest("compiler/testData/codegen/box/callableReference/inlineArrayConstructors.kt"); } + @Test @TestMetadata("kt21014.kt") public void testKt21014() throws Exception { runTest("compiler/testData/codegen/box/callableReference/kt21014.kt"); } + @Test @TestMetadata("kt21092a.kt") public void testKt21092a() throws Exception { runTest("compiler/testData/codegen/box/callableReference/kt21092a.kt"); } + @Test @TestMetadata("kt37604.kt") public void testKt37604() throws Exception { runTest("compiler/testData/codegen/box/callableReference/kt37604.kt"); } + @Test @TestMetadata("kt44483.kt") public void testKt44483() throws Exception { runTest("compiler/testData/codegen/box/callableReference/kt44483.kt"); } + @Test @TestMetadata("kt46902.kt") public void testKt46902() throws Exception { runTest("compiler/testData/codegen/box/callableReference/kt46902.kt"); } + @Test @TestMetadata("kt47988.kt") public void testKt47988() throws Exception { runTest("compiler/testData/codegen/box/callableReference/kt47988.kt"); } + @Test @TestMetadata("kt49526.kt") public void testKt49526() throws Exception { runTest("compiler/testData/codegen/box/callableReference/kt49526.kt"); } + @Test @TestMetadata("kt49526_sam.kt") public void testKt49526_sam() throws Exception { runTest("compiler/testData/codegen/box/callableReference/kt49526_sam.kt"); } + @Test @TestMetadata("kt49526a.kt") public void testKt49526a() throws Exception { runTest("compiler/testData/codegen/box/callableReference/kt49526a.kt"); } + @Test @TestMetadata("kt49526b.kt") public void testKt49526b() throws Exception { runTest("compiler/testData/codegen/box/callableReference/kt49526b.kt"); } + @Test @TestMetadata("kt50172.kt") public void testKt50172() throws Exception { runTest("compiler/testData/codegen/box/callableReference/kt50172.kt"); } + @Test @TestMetadata("kt51844.kt") public void testKt51844() throws Exception { runTest("compiler/testData/codegen/box/callableReference/kt51844.kt"); } + @Test @TestMetadata("kt52270.kt") public void testKt52270() throws Exception { runTest("compiler/testData/codegen/box/callableReference/kt52270.kt"); } + @Test @TestMetadata("nested.kt") public void testNested() throws Exception { runTest("compiler/testData/codegen/box/callableReference/nested.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/callableReference/adaptedReferences") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class AdaptedReferences extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class AdaptedReferences { + @Test @TestMetadata("adaptedArrayOf.kt") public void testAdaptedArrayOf() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/adaptedArrayOf.kt"); } + @Test @TestMetadata("adaptedVarargFunImportedFromObject.kt") public void testAdaptedVarargFunImportedFromObject() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/adaptedVarargFunImportedFromObject.kt"); } + @Test public void testAllFilesPresentInAdaptedReferences() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("bothWithCoercionToUnit.kt") public void testBothWithCoercionToUnit() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/bothWithCoercionToUnit.kt"); } + @Test @TestMetadata("boundReferences.kt") public void testBoundReferences() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/boundReferences.kt"); } + @Test @TestMetadata("defaultAfterVararg.kt") public void testDefaultAfterVararg() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/defaultAfterVararg.kt"); } + @Test @TestMetadata("defaultWithGenericExpectedType.kt") public void testDefaultWithGenericExpectedType() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/defaultWithGenericExpectedType.kt"); } + @Test @TestMetadata("emptyVarargAndDefault.kt") public void testEmptyVarargAndDefault() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/emptyVarargAndDefault.kt"); } + @Test @TestMetadata("inlineBound.kt") public void testInlineBound() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/inlineBound.kt"); } + @Test @TestMetadata("inlineDefault.kt") public void testInlineDefault() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/inlineDefault.kt"); } + @Test @TestMetadata("inlineVararg.kt") public void testInlineVararg() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/inlineVararg.kt"); } + @Test @TestMetadata("inlineVarargAndDefault.kt") public void testInlineVarargAndDefault() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/inlineVarargAndDefault.kt"); } + @Test @TestMetadata("inlineVarargInts.kt") public void testInlineVarargInts() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/inlineVarargInts.kt"); } + @Test @TestMetadata("innerConstructorWithVararg.kt") public void testInnerConstructorWithVararg() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/innerConstructorWithVararg.kt"); } + @Test @TestMetadata("largeVararg.kt") public void testLargeVararg() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/largeVararg.kt"); } + @Test @TestMetadata("localFunctionWithDefault.kt") public void testLocalFunctionWithDefault() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/localFunctionWithDefault.kt"); } + @Test @TestMetadata("manyDefaultsAndVararg.kt") public void testManyDefaultsAndVararg() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/manyDefaultsAndVararg.kt"); } + @Test @TestMetadata("nestedClassConstructorWithDefault.kt") public void testNestedClassConstructorWithDefault() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/nestedClassConstructorWithDefault.kt"); } + @Test @TestMetadata("noNameClashForReferencesToSameFunction.kt") public void testNoNameClashForReferencesToSameFunction() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/noNameClashForReferencesToSameFunction.kt"); } + @Test @TestMetadata("referenceToVarargWithDefaults.kt") public void testReferenceToVarargWithDefaults() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/referenceToVarargWithDefaults.kt"); } + @Test @TestMetadata("simpleDefaultArgument.kt") public void testSimpleDefaultArgument() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/simpleDefaultArgument.kt"); } + @Test @TestMetadata("simpleEmptyVararg.kt") public void testSimpleEmptyVararg() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/simpleEmptyVararg.kt"); } + @Test @TestMetadata("suspendUnitConversion.kt") public void testSuspendUnitConversion() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendUnitConversion.kt"); } + @Test @TestMetadata("unboundReferences.kt") public void testUnboundReferences() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/unboundReferences.kt"); } + @Test @TestMetadata("varargFromBaseClass.kt") public void testVarargFromBaseClass() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/varargFromBaseClass.kt"); } + @Test @TestMetadata("varargViewedAsArray.kt") public void testVarargViewedAsArray() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/varargViewedAsArray.kt"); } + @Test @TestMetadata("varargViewedAsPrimitiveArray.kt") public void testVarargViewedAsPrimitiveArray() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/varargViewedAsPrimitiveArray.kt"); } + @Test @TestMetadata("varargWithDefaultValue.kt") public void testVarargWithDefaultValue() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/varargWithDefaultValue.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SuspendConversion extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class SuspendConversion { + @Test @TestMetadata("adaptedWithCoercionToUnit.kt") public void testAdaptedWithCoercionToUnit() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/adaptedWithCoercionToUnit.kt"); } + @Test @TestMetadata("adaptedWithDefaultArguments.kt") public void testAdaptedWithDefaultArguments() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/adaptedWithDefaultArguments.kt"); } + @Test @TestMetadata("adaptedWithVarargs.kt") public void testAdaptedWithVarargs() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/adaptedWithVarargs.kt"); } + @Test public void testAllFilesPresentInSuspendConversion() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("bound.kt") public void testBound() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/bound.kt"); } + @Test @TestMetadata("boundExtension.kt") public void testBoundExtension() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/boundExtension.kt"); } + @Test @TestMetadata("crossInline.kt") public void testCrossInline() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/crossInline.kt"); } + @Test @TestMetadata("inlineAdaptedWithCoercionToUnit.kt") public void testInlineAdaptedWithCoercionToUnit() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/inlineAdaptedWithCoercionToUnit.kt"); } + @Test @TestMetadata("inlineAdaptedWithDefaultArguments.kt") public void testInlineAdaptedWithDefaultArguments() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/inlineAdaptedWithDefaultArguments.kt"); } + @Test @TestMetadata("inlineAdaptedWithVarargs.kt") public void testInlineAdaptedWithVarargs() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/inlineAdaptedWithVarargs.kt"); } + @Test @TestMetadata("inlineBound.kt") public void testInlineBound() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/inlineBound.kt"); } + @Test @TestMetadata("inlineSimple.kt") public void testInlineSimple() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/inlineSimple.kt"); } + @Test @TestMetadata("inlineWithParameters.kt") public void testInlineWithParameters() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/inlineWithParameters.kt"); } + @Test @TestMetadata("isAs.kt") public void testIsAs() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/isAs.kt"); } + @Test @TestMetadata("nullableParameter.kt") public void testNullableParameter() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/nullableParameter.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/simple.kt"); } + @Test @TestMetadata("withParameters.kt") public void testWithParameters() throws Exception { runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/withParameters.kt"); @@ -2079,175 +2327,199 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/callableReference/bound") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Bound extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Bound { + @Test @TestMetadata("adapted.kt") public void testAdapted() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/adapted.kt"); } + @Test public void testAllFilesPresentInBound() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("array.kt") public void testArray() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/array.kt"); } + @Test @TestMetadata("arrayConstructorArgument.kt") public void testArrayConstructorArgument() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/arrayConstructorArgument.kt"); } + @Test @TestMetadata("arrayGetIntrinsic.kt") public void testArrayGetIntrinsic() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/arrayGetIntrinsic.kt"); } + @Test @TestMetadata("boundReferenceToOverloadedFunction.kt") public void testBoundReferenceToOverloadedFunction() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/boundReferenceToOverloadedFunction.kt"); } + @Test @TestMetadata("captureVarInInitBlock.kt") public void testCaptureVarInInitBlock() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/captureVarInInitBlock.kt"); } + @Test @TestMetadata("captureVarInPropertyInit.kt") public void testCaptureVarInPropertyInit() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/captureVarInPropertyInit.kt"); } + @Test @TestMetadata("coercionToUnit.kt") public void testCoercionToUnit() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/coercionToUnit.kt"); } + @Test @TestMetadata("companionObjectReceiver.kt") public void testCompanionObjectReceiver() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/companionObjectReceiver.kt"); } + @Test @TestMetadata("companionObjectReceiverInheritsFromOuter.kt") public void testCompanionObjectReceiverInheritsFromOuter() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/companionObjectReceiverInheritsFromOuter.kt"); } + @Test @TestMetadata("dontShareReceiver.kt") public void testDontShareReceiver() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/dontShareReceiver.kt"); } + @Test @TestMetadata("emptyLHS.kt") public void testEmptyLHS() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/emptyLHS.kt"); } + @Test @TestMetadata("enumEntryMember.kt") public void testEnumEntryMember() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/enumEntryMember.kt"); } + @Test @TestMetadata("genericBoundPropertyAsCrossinline.kt") public void testGenericBoundPropertyAsCrossinline() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/genericBoundPropertyAsCrossinline.kt"); } + @Test @TestMetadata("genericValOnLHS.kt") public void testGenericValOnLHS() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/genericValOnLHS.kt"); } + @Test @TestMetadata("kCallableNameIntrinsic.kt") public void testKCallableNameIntrinsic() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/kCallableNameIntrinsic.kt"); } + @Test @TestMetadata("kt12738.kt") public void testKt12738() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/kt12738.kt"); } + @Test @TestMetadata("kt15446.kt") public void testKt15446() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/kt15446.kt"); } + @Test @TestMetadata("kt44636_localExtension.kt") public void testKt44636_localExtension() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/kt44636_localExtension.kt"); } + @Test @TestMetadata("multiCase.kt") public void testMultiCase() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/multiCase.kt"); } + @Test @TestMetadata("nullReceiver.kt") public void testNullReceiver() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/nullReceiver.kt"); } + @Test @TestMetadata("objectReceiver.kt") public void testObjectReceiver() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/objectReceiver.kt"); } + @Test @TestMetadata("primitiveReceiver.kt") public void testPrimitiveReceiver() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/primitiveReceiver.kt"); } + @Test @TestMetadata("receiverEvaluatedOnce.kt") public void testReceiverEvaluatedOnce() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/receiverEvaluatedOnce.kt"); } + @Test @TestMetadata("simpleFunction.kt") public void testSimpleFunction() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/simpleFunction.kt"); } + @Test @TestMetadata("simpleProperty.kt") public void testSimpleProperty() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/simpleProperty.kt"); } + @Test @TestMetadata("smartCastForExtensionReceiver.kt") public void testSmartCastForExtensionReceiver() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/smartCastForExtensionReceiver.kt"); } + @Test @TestMetadata("typeAliasObjectBoundReference.kt") public void testTypeAliasObjectBoundReference() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/typeAliasObjectBoundReference.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/callableReference/bound/equals") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Equals extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Equals { + @Test public void testAllFilesPresentInEquals() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound/equals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("nullableReceiverInEquals.kt") public void testNullableReceiverInEquals() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/equals/nullableReceiverInEquals.kt"); } + @Test @TestMetadata("receiverInEquals.kt") public void testReceiverInEquals() throws Exception { runTest("compiler/testData/codegen/box/callableReference/bound/equals/receiverInEquals.kt"); @@ -2255,516 +2527,597 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/callableReference/equality") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Equality extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Equality { + @Test public void testAllFilesPresentInEquality() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/equality"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("capturedDefaults.kt") public void testCapturedDefaults() throws Exception { runTest("compiler/testData/codegen/box/callableReference/equality/capturedDefaults.kt"); } + @Test @TestMetadata("capturedVararg.kt") public void testCapturedVararg() throws Exception { runTest("compiler/testData/codegen/box/callableReference/equality/capturedVararg.kt"); } + @Test @TestMetadata("coercionToUnit.kt") public void testCoercionToUnit() throws Exception { runTest("compiler/testData/codegen/box/callableReference/equality/coercionToUnit.kt"); } + @Test @TestMetadata("coercionToUnitWithDefaults.kt") public void testCoercionToUnitWithDefaults() throws Exception { runTest("compiler/testData/codegen/box/callableReference/equality/coercionToUnitWithDefaults.kt"); } + @Test @TestMetadata("coercionToUnitWithVararg.kt") public void testCoercionToUnitWithVararg() throws Exception { runTest("compiler/testData/codegen/box/callableReference/equality/coercionToUnitWithVararg.kt"); } + @Test @TestMetadata("conversionCombinations.kt") public void testConversionCombinations() throws Exception { runTest("compiler/testData/codegen/box/callableReference/equality/conversionCombinations.kt"); } + @Test @TestMetadata("extensionReceiverVsDefault.kt") public void testExtensionReceiverVsDefault() throws Exception { runTest("compiler/testData/codegen/box/callableReference/equality/extensionReceiverVsDefault.kt"); } + @Test @TestMetadata("noCoercionToUnitIfFunctionAlreadyReturnsUnit.kt") public void testNoCoercionToUnitIfFunctionAlreadyReturnsUnit() throws Exception { runTest("compiler/testData/codegen/box/callableReference/equality/noCoercionToUnitIfFunctionAlreadyReturnsUnit.kt"); } + @Test @TestMetadata("simpleEquality.kt") public void testSimpleEquality() throws Exception { runTest("compiler/testData/codegen/box/callableReference/equality/simpleEquality.kt"); } + @Test @TestMetadata("suspendConversion.kt") public void testSuspendConversion() throws Exception { runTest("compiler/testData/codegen/box/callableReference/equality/suspendConversion.kt"); } + @Test @TestMetadata("varargAsArrayMemberOrExtension.kt") public void testVarargAsArrayMemberOrExtension() throws Exception { runTest("compiler/testData/codegen/box/callableReference/equality/varargAsArrayMemberOrExtension.kt"); } + @Test @TestMetadata("varargAsArrayWithDefaults.kt") public void testVarargAsArrayWithDefaults() throws Exception { runTest("compiler/testData/codegen/box/callableReference/equality/varargAsArrayWithDefaults.kt"); } + @Test @TestMetadata("varargWithDefaults.kt") public void testVarargWithDefaults() throws Exception { runTest("compiler/testData/codegen/box/callableReference/equality/varargWithDefaults.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/callableReference/funInterfaceConstructor") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class FunInterfaceConstructor extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class FunInterfaceConstructor { + @Test public void testAllFilesPresentInFunInterfaceConstructor() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/funInterfaceConstructor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("funInterfaceConstructedObjectsEquality.kt") public void testFunInterfaceConstructedObjectsEquality() throws Exception { runTest("compiler/testData/codegen/box/callableReference/funInterfaceConstructor/funInterfaceConstructedObjectsEquality.kt"); } + @Test @TestMetadata("funInterfaceConstructor.kt") public void testFunInterfaceConstructor() throws Exception { runTest("compiler/testData/codegen/box/callableReference/funInterfaceConstructor/funInterfaceConstructor.kt"); } + @Test @TestMetadata("funInterfaceConstructorEquality.kt") public void testFunInterfaceConstructorEquality() throws Exception { runTest("compiler/testData/codegen/box/callableReference/funInterfaceConstructor/funInterfaceConstructorEquality.kt"); } + @Test @TestMetadata("funInterfaceConstructorIsKFunction.kt") public void testFunInterfaceConstructorIsKFunction() throws Exception { runTest("compiler/testData/codegen/box/callableReference/funInterfaceConstructor/funInterfaceConstructorIsKFunction.kt"); } + @Test @TestMetadata("funInterfaceConstructorOfImplicitKFunctionType.kt") public void testFunInterfaceConstructorOfImplicitKFunctionType() throws Exception { runTest("compiler/testData/codegen/box/callableReference/funInterfaceConstructor/funInterfaceConstructorOfImplicitKFunctionType.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/callableReference/function") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Function extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Function { + @Test @TestMetadata("abstractClassMember.kt") public void testAbstractClassMember() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/abstractClassMember.kt"); } + @Test public void testAllFilesPresentInFunction() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("argumentTypes.kt") public void testArgumentTypes() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/argumentTypes.kt"); } + @Test @TestMetadata("argumentTypesNoinline.kt") public void testArgumentTypesNoinline() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/argumentTypesNoinline.kt"); } + @Test @TestMetadata("booleanNotIntrinsic.kt") public void testBooleanNotIntrinsic() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/booleanNotIntrinsic.kt"); } + @Test @TestMetadata("classMemberFromClass.kt") public void testClassMemberFromClass() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/classMemberFromClass.kt"); } + @Test @TestMetadata("classMemberFromCompanionObject.kt") public void testClassMemberFromCompanionObject() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/classMemberFromCompanionObject.kt"); } + @Test @TestMetadata("classMemberFromExtension.kt") public void testClassMemberFromExtension() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/classMemberFromExtension.kt"); } + @Test @TestMetadata("classMemberFromTopLevelStringNoArgs.kt") public void testClassMemberFromTopLevelStringNoArgs() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/classMemberFromTopLevelStringNoArgs.kt"); } + @Test @TestMetadata("classMemberFromTopLevelStringOneStringArg.kt") public void testClassMemberFromTopLevelStringOneStringArg() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/classMemberFromTopLevelStringOneStringArg.kt"); } + @Test @TestMetadata("classMemberFromTopLevelUnitNoArgs.kt") public void testClassMemberFromTopLevelUnitNoArgs() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/classMemberFromTopLevelUnitNoArgs.kt"); } + @Test @TestMetadata("classMemberFromTopLevelUnitOneStringArg.kt") public void testClassMemberFromTopLevelUnitOneStringArg() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/classMemberFromTopLevelUnitOneStringArg.kt"); } + @Test @TestMetadata("coercionToUnit.kt") public void testCoercionToUnit() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/coercionToUnit.kt"); } + @Test @TestMetadata("constructorFromTopLevelNoArgs.kt") public void testConstructorFromTopLevelNoArgs() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/constructorFromTopLevelNoArgs.kt"); } + @Test @TestMetadata("constructorFromTopLevelOneStringArg.kt") public void testConstructorFromTopLevelOneStringArg() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/constructorFromTopLevelOneStringArg.kt"); } + @Test @TestMetadata("enumValueOfMethod.kt") public void testEnumValueOfMethod() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/enumValueOfMethod.kt"); } + @Test @TestMetadata("equalsIntrinsic.kt") public void testEqualsIntrinsic() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/equalsIntrinsic.kt"); } + @Test @TestMetadata("extensionFromClass.kt") public void testExtensionFromClass() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/extensionFromClass.kt"); } + @Test @TestMetadata("extensionFromExtension.kt") public void testExtensionFromExtension() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/extensionFromExtension.kt"); } + @Test @TestMetadata("extensionFromTopLevelStringNoArgs.kt") public void testExtensionFromTopLevelStringNoArgs() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/extensionFromTopLevelStringNoArgs.kt"); } + @Test @TestMetadata("extensionFromTopLevelStringOneStringArg.kt") public void testExtensionFromTopLevelStringOneStringArg() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/extensionFromTopLevelStringOneStringArg.kt"); } + @Test @TestMetadata("extensionFromTopLevelUnitNoArgs.kt") public void testExtensionFromTopLevelUnitNoArgs() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/extensionFromTopLevelUnitNoArgs.kt"); } + @Test @TestMetadata("extensionFromTopLevelUnitOneStringArg.kt") public void testExtensionFromTopLevelUnitOneStringArg() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/extensionFromTopLevelUnitOneStringArg.kt"); } + @Test @TestMetadata("genericCallableReferenceArgumentsNonJVM.kt") public void testGenericCallableReferenceArgumentsNonJVM() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/genericCallableReferenceArgumentsNonJVM.kt"); } + @Test @TestMetadata("genericCallableReferenceWithReifiedTypeParam.kt") public void testGenericCallableReferenceWithReifiedTypeParam() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/genericCallableReferenceWithReifiedTypeParam.kt"); } + @Test @TestMetadata("genericCallableReferencesWithNullableTypes.kt") public void testGenericCallableReferencesWithNullableTypes() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/genericCallableReferencesWithNullableTypes.kt"); } + @Test @TestMetadata("genericCallableReferencesWithOverload.kt") public void testGenericCallableReferencesWithOverload() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/genericCallableReferencesWithOverload.kt"); } + @Test @TestMetadata("genericMember.kt") public void testGenericMember() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/genericMember.kt"); } + @Test @TestMetadata("genericWithDependentType.kt") public void testGenericWithDependentType() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/genericWithDependentType.kt"); } + @Test @TestMetadata("innerClassConstructorWithTwoReceivers.kt") public void testInnerClassConstructorWithTwoReceivers() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/innerClassConstructorWithTwoReceivers.kt"); } + @Test @TestMetadata("innerConstructorFromClass.kt") public void testInnerConstructorFromClass() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/innerConstructorFromClass.kt"); } + @Test @TestMetadata("innerConstructorFromExtension.kt") public void testInnerConstructorFromExtension() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/innerConstructorFromExtension.kt"); } + @Test @TestMetadata("innerConstructorFromTopLevelNoArgs.kt") public void testInnerConstructorFromTopLevelNoArgs() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/innerConstructorFromTopLevelNoArgs.kt"); } + @Test @TestMetadata("innerConstructorFromTopLevelOneStringArg.kt") public void testInnerConstructorFromTopLevelOneStringArg() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/innerConstructorFromTopLevelOneStringArg.kt"); } + @Test @TestMetadata("kt21787.kt") public void testKt21787() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/kt21787.kt"); } + @Test @TestMetadata("kt32462.kt") public void testKt32462() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/kt32462.kt"); } + @Test @TestMetadata("kt47741.kt") public void testKt47741() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/kt47741.kt"); } + @Test @TestMetadata("nestedConstructorFromClass.kt") public void testNestedConstructorFromClass() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/nestedConstructorFromClass.kt"); } + @Test @TestMetadata("nestedConstructorFromTopLevelNoArgs.kt") public void testNestedConstructorFromTopLevelNoArgs() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/nestedConstructorFromTopLevelNoArgs.kt"); } + @Test @TestMetadata("nestedConstructorFromTopLevelOneStringArg.kt") public void testNestedConstructorFromTopLevelOneStringArg() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/nestedConstructorFromTopLevelOneStringArg.kt"); } + @Test @TestMetadata("newArray.kt") public void testNewArray() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/newArray.kt"); } + @Test @TestMetadata("overloadedFun.kt") public void testOverloadedFun() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/overloadedFun.kt"); } + @Test @TestMetadata("overloadedFunVsVal.kt") public void testOverloadedFunVsVal() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/overloadedFunVsVal.kt"); } + @Test @TestMetadata("privateClassMember.kt") public void testPrivateClassMember() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/privateClassMember.kt"); } + @Test @TestMetadata("referenceToCompanionMember.kt") public void testReferenceToCompanionMember() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/referenceToCompanionMember.kt"); } + @Test @TestMetadata("sortListOfStrings.kt") public void testSortListOfStrings() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/sortListOfStrings.kt"); } + @Test @TestMetadata("specialCalls.kt") public void testSpecialCalls() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/specialCalls.kt"); } + @Test @TestMetadata("topLevelFromClass.kt") public void testTopLevelFromClass() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/topLevelFromClass.kt"); } + @Test @TestMetadata("topLevelFromExtension.kt") public void testTopLevelFromExtension() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/topLevelFromExtension.kt"); } + @Test @TestMetadata("topLevelFromTopLevelStringNoArgs.kt") public void testTopLevelFromTopLevelStringNoArgs() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/topLevelFromTopLevelStringNoArgs.kt"); } + @Test @TestMetadata("topLevelFromTopLevelStringOneStringArg.kt") public void testTopLevelFromTopLevelStringOneStringArg() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/topLevelFromTopLevelStringOneStringArg.kt"); } + @Test @TestMetadata("topLevelFromTopLevelUnitManyArgs.kt") public void testTopLevelFromTopLevelUnitManyArgs() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/topLevelFromTopLevelUnitManyArgs.kt"); } + @Test @TestMetadata("topLevelFromTopLevelUnitNoArgs.kt") public void testTopLevelFromTopLevelUnitNoArgs() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/topLevelFromTopLevelUnitNoArgs.kt"); } + @Test @TestMetadata("topLevelFromTopLevelUnitOneStringArg.kt") public void testTopLevelFromTopLevelUnitOneStringArg() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/topLevelFromTopLevelUnitOneStringArg.kt"); } + @Test @TestMetadata("traitImplMethodWithClassReceiver.kt") public void testTraitImplMethodWithClassReceiver() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/traitImplMethodWithClassReceiver.kt"); } + @Test @TestMetadata("traitMember.kt") public void testTraitMember() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/traitMember.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/callableReference/function/local") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Local extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Local { + @Test public void testAllFilesPresentInLocal() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function/local"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("captureOuter.kt") public void testCaptureOuter() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/local/captureOuter.kt"); } + @Test @TestMetadata("classMember.kt") public void testClassMember() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/local/classMember.kt"); } + @Test @TestMetadata("closureWithSideEffect.kt") public void testClosureWithSideEffect() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/local/closureWithSideEffect.kt"); } + @Test @TestMetadata("constructor.kt") public void testConstructor() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/local/constructor.kt"); } + @Test @TestMetadata("constructorWithInitializer.kt") public void testConstructorWithInitializer() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/local/constructorWithInitializer.kt"); } + @Test @TestMetadata("enumExtendsTrait.kt") public void testEnumExtendsTrait() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/local/enumExtendsTrait.kt"); } + @Test @TestMetadata("equalsHashCode.kt") public void testEqualsHashCode() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/local/equalsHashCode.kt"); } + @Test @TestMetadata("extension.kt") public void testExtension() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/local/extension.kt"); } + @Test @TestMetadata("extensionToLocalClass.kt") public void testExtensionToLocalClass() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/local/extensionToLocalClass.kt"); } + @Test @TestMetadata("extensionToPrimitive.kt") public void testExtensionToPrimitive() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/local/extensionToPrimitive.kt"); } + @Test @TestMetadata("extensionWithClosure.kt") public void testExtensionWithClosure() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/local/extensionWithClosure.kt"); } + @Test @TestMetadata("genericMember.kt") public void testGenericMember() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/local/genericMember.kt"); } + @Test @TestMetadata("localClassMember.kt") public void testLocalClassMember() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/local/localClassMember.kt"); } + @Test @TestMetadata("localFunctionName.kt") public void testLocalFunctionName() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/local/localFunctionName.kt"); } + @Test @TestMetadata("localLocal.kt") public void testLocalLocal() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/local/localLocal.kt"); } + @Test @TestMetadata("recursiveClosure.kt") public void testRecursiveClosure() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/local/recursiveClosure.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/local/simple.kt"); } + @Test @TestMetadata("simpleClosure.kt") public void testSimpleClosure() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/local/simpleClosure.kt"); } + @Test @TestMetadata("simpleWithArg.kt") public void testSimpleWithArg() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/local/simpleWithArg.kt"); } + @Test @TestMetadata("unitWithSideEffect.kt") public void testUnitWithSideEffect() throws Exception { runTest("compiler/testData/codegen/box/callableReference/function/local/unitWithSideEffect.kt"); @@ -2772,1247 +3125,1418 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/callableReference/property") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Property extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Property { + @Test @TestMetadata("accessViaSubclass.kt") public void testAccessViaSubclass() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/accessViaSubclass.kt"); } + @Test @TestMetadata("accessorForPropertyWithPrivateSetter.kt") public void testAccessorForPropertyWithPrivateSetter() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/accessorForPropertyWithPrivateSetter.kt"); } + @Test public void testAllFilesPresentInProperty() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/property"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("delegated.kt") public void testDelegated() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/delegated.kt"); } + @Test @TestMetadata("delegatedMutable.kt") public void testDelegatedMutable() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/delegatedMutable.kt"); } + @Test @TestMetadata("enumNameOrdinal.kt") public void testEnumNameOrdinal() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/enumNameOrdinal.kt"); } + @Test @TestMetadata("extensionToArray.kt") public void testExtensionToArray() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/extensionToArray.kt"); } + @Test @TestMetadata("genericProperty.kt") public void testGenericProperty() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/genericProperty.kt"); } + @Test @TestMetadata("inEnum.kt") public void testInEnum() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/inEnum.kt"); } + @Test @TestMetadata("inReceiverOfAnother.kt") public void testInReceiverOfAnother() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/inReceiverOfAnother.kt"); } + @Test @TestMetadata("invokePropertyReference.kt") public void testInvokePropertyReference() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/invokePropertyReference.kt"); } + @Test @TestMetadata("javaBeanConvention.kt") public void testJavaBeanConvention() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/javaBeanConvention.kt"); } + @Test @TestMetadata("kClassInstanceIsInitializedFirst.kt") public void testKClassInstanceIsInitializedFirst() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/kClassInstanceIsInitializedFirst.kt"); } + @Test @TestMetadata("kt12044.kt") public void testKt12044() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/kt12044.kt"); } + @Test @TestMetadata("kt12982_protectedPropertyReference.kt") public void testKt12982_protectedPropertyReference() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/kt12982_protectedPropertyReference.kt"); } + @Test @TestMetadata("kt14330.kt") public void testKt14330() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/kt14330.kt"); } + @Test @TestMetadata("kt14330_2.kt") public void testKt14330_2() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/kt14330_2.kt"); } + @Test @TestMetadata("kt15447.kt") public void testKt15447() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/kt15447.kt"); } + @Test @TestMetadata("listOfStringsMapLength.kt") public void testListOfStringsMapLength() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/listOfStringsMapLength.kt"); } + @Test @TestMetadata("localClassVar.kt") public void testLocalClassVar() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/localClassVar.kt"); } + @Test @TestMetadata("overriddenInSubclass.kt") public void testOverriddenInSubclass() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/overriddenInSubclass.kt"); } + @Test @TestMetadata("privateSetOuterClass.kt") public void testPrivateSetOuterClass() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/privateSetOuterClass.kt"); } + @Test @TestMetadata("privateSetterInsideClass.kt") public void testPrivateSetterInsideClass() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/privateSetterInsideClass.kt"); } + @Test @TestMetadata("privateSetterOutsideClass.kt") public void testPrivateSetterOutsideClass() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/privateSetterOutsideClass.kt"); } + @Test @TestMetadata("receiverEvaluatedOnce.kt") public void testReceiverEvaluatedOnce() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/receiverEvaluatedOnce.kt"); } + @Test @TestMetadata("simpleExtension.kt") public void testSimpleExtension() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/simpleExtension.kt"); } + @Test @TestMetadata("simpleMember.kt") public void testSimpleMember() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/simpleMember.kt"); } + @Test @TestMetadata("simpleMutableExtension.kt") public void testSimpleMutableExtension() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/simpleMutableExtension.kt"); } + @Test @TestMetadata("simpleMutableMember.kt") public void testSimpleMutableMember() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/simpleMutableMember.kt"); } + @Test @TestMetadata("simpleMutableTopLevel.kt") public void testSimpleMutableTopLevel() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/simpleMutableTopLevel.kt"); } + @Test @TestMetadata("simpleTopLevel.kt") public void testSimpleTopLevel() throws Exception { runTest("compiler/testData/codegen/box/callableReference/property/simpleTopLevel.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/callableReference/serializability") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Serializability extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Serializability { + @Test public void testAllFilesPresentInSerializability() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/serializability"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/casts") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Casts extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Casts { + @Test public void testAllFilesPresentInCasts() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("asForConstants.kt") public void testAsForConstants() throws Exception { runTest("compiler/testData/codegen/box/casts/asForConstants.kt"); } + @Test @TestMetadata("asSafeFail.kt") public void testAsSafeFail() throws Exception { runTest("compiler/testData/codegen/box/casts/asSafeFail.kt"); } + @Test @TestMetadata("asSafeForConstants.kt") public void testAsSafeForConstants() throws Exception { runTest("compiler/testData/codegen/box/casts/asSafeForConstants.kt"); } + @Test @TestMetadata("asUnit.kt") public void testAsUnit() throws Exception { runTest("compiler/testData/codegen/box/casts/asUnit.kt"); } + @Test @TestMetadata("asWithGeneric.kt") public void testAsWithGeneric() throws Exception { runTest("compiler/testData/codegen/box/casts/asWithGeneric.kt"); } + @Test @TestMetadata("castGenericNull.kt") public void testCastGenericNull() throws Exception { runTest("compiler/testData/codegen/box/casts/castGenericNull.kt"); } + @Test @TestMetadata("castToDefinitelyNotNullType.kt") public void testCastToDefinitelyNotNullType() throws Exception { runTest("compiler/testData/codegen/box/casts/castToDefinitelyNotNullType.kt"); } + @Test @TestMetadata("dontCreateInconsistentTypeDuringStarProjectionSubstitution.kt") public void testDontCreateInconsistentTypeDuringStarProjectionSubstitution() throws Exception { runTest("compiler/testData/codegen/box/casts/dontCreateInconsistentTypeDuringStarProjectionSubstitution.kt"); } + @Test @TestMetadata("genericReturnCast.kt") public void testGenericReturnCast() throws Exception { runTest("compiler/testData/codegen/box/casts/genericReturnCast.kt"); } + @Test @TestMetadata("intersectionTypeMultipleBounds.kt") public void testIntersectionTypeMultipleBounds() throws Exception { runTest("compiler/testData/codegen/box/casts/intersectionTypeMultipleBounds.kt"); } + @Test @TestMetadata("intersectionTypeMultipleBoundsImplicitReceiver.kt") public void testIntersectionTypeMultipleBoundsImplicitReceiver() throws Exception { runTest("compiler/testData/codegen/box/casts/intersectionTypeMultipleBoundsImplicitReceiver.kt"); } + @Test @TestMetadata("intersectionTypeSmartcast.kt") public void testIntersectionTypeSmartcast() throws Exception { runTest("compiler/testData/codegen/box/casts/intersectionTypeSmartcast.kt"); } + @Test @TestMetadata("intersectionTypeWithMultipleBoundsAsReceiver.kt") public void testIntersectionTypeWithMultipleBoundsAsReceiver() throws Exception { runTest("compiler/testData/codegen/box/casts/intersectionTypeWithMultipleBoundsAsReceiver.kt"); } + @Test @TestMetadata("intersectionTypeWithoutGenericsAsReceiver.kt") public void testIntersectionTypeWithoutGenericsAsReceiver() throws Exception { runTest("compiler/testData/codegen/box/casts/intersectionTypeWithoutGenericsAsReceiver.kt"); } + @Test @TestMetadata("isNullablePrimitive.kt") public void testIsNullablePrimitive() throws Exception { runTest("compiler/testData/codegen/box/casts/isNullablePrimitive.kt"); } + @Test @TestMetadata("kt22714.kt") public void testKt22714() throws Exception { runTest("compiler/testData/codegen/box/casts/kt22714.kt"); } + @Test @TestMetadata("kt48927_privateMethodOnDerivedCastToBase.kt") public void testKt48927_privateMethodOnDerivedCastToBase() throws Exception { runTest("compiler/testData/codegen/box/casts/kt48927_privateMethodOnDerivedCastToBase.kt"); } + @Test @TestMetadata("kt50577.kt") public void testKt50577() throws Exception { runTest("compiler/testData/codegen/box/casts/kt50577.kt"); } + @Test @TestMetadata("kt53677.kt") public void testKt53677() throws Exception { runTest("compiler/testData/codegen/box/casts/kt53677.kt"); } + @Test @TestMetadata("kt54707.kt") public void testKt54707() throws Exception { runTest("compiler/testData/codegen/box/casts/kt54707.kt"); } + @Test @TestMetadata("kt54802.kt") public void testKt54802() throws Exception { runTest("compiler/testData/codegen/box/casts/kt54802.kt"); } + @Test @TestMetadata("kt58707.kt") public void testKt58707() throws Exception { runTest("compiler/testData/codegen/box/casts/kt58707.kt"); } + @Test @TestMetadata("kt59022.kt") public void testKt59022() throws Exception { runTest("compiler/testData/codegen/box/casts/kt59022.kt"); } + @Test @TestMetadata("lambdaToUnitCast.kt") public void testLambdaToUnitCast() throws Exception { runTest("compiler/testData/codegen/box/casts/lambdaToUnitCast.kt"); } + @Test @TestMetadata("nullableSafeCastToTypeParameterWithInterfaceUpperBound.kt") public void testNullableSafeCastToTypeParameterWithInterfaceUpperBound() throws Exception { runTest("compiler/testData/codegen/box/casts/nullableSafeCastToTypeParameterWithInterfaceUpperBound.kt"); } + @Test @TestMetadata("objectToPrimitiveWithAssertion.kt") public void testObjectToPrimitiveWithAssertion() throws Exception { runTest("compiler/testData/codegen/box/casts/objectToPrimitiveWithAssertion.kt"); } + @Test @TestMetadata("unitAsAny.kt") public void testUnitAsAny() throws Exception { runTest("compiler/testData/codegen/box/casts/unitAsAny.kt"); } + @Test @TestMetadata("unitAsSafeAny.kt") public void testUnitAsSafeAny() throws Exception { runTest("compiler/testData/codegen/box/casts/unitAsSafeAny.kt"); } + @Test @TestMetadata("unitNullableCast.kt") public void testUnitNullableCast() throws Exception { runTest("compiler/testData/codegen/box/casts/unitNullableCast.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/casts/functions") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Functions extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Functions { + @Test public void testAllFilesPresentInFunctions() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/functions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("asFunKBig.kt") public void testAsFunKBig() throws Exception { runTest("compiler/testData/codegen/box/casts/functions/asFunKBig.kt"); } + @Test @TestMetadata("asFunKSmall.kt") public void testAsFunKSmall() throws Exception { runTest("compiler/testData/codegen/box/casts/functions/asFunKSmall.kt"); } + @Test @TestMetadata("isFunKBig.kt") public void testIsFunKBig() throws Exception { runTest("compiler/testData/codegen/box/casts/functions/isFunKBig.kt"); } + @Test @TestMetadata("isFunKSmall.kt") public void testIsFunKSmall() throws Exception { runTest("compiler/testData/codegen/box/casts/functions/isFunKSmall.kt"); } + @Test @TestMetadata("isFunKSmallNonJS.kt") public void testIsFunKSmallNonJS() throws Exception { runTest("compiler/testData/codegen/box/casts/functions/isFunKSmallNonJS.kt"); } + @Test @TestMetadata("reifiedAsFunKBig.kt") public void testReifiedAsFunKBig() throws Exception { runTest("compiler/testData/codegen/box/casts/functions/reifiedAsFunKBig.kt"); } + @Test @TestMetadata("reifiedAsFunKSmall.kt") public void testReifiedAsFunKSmall() throws Exception { runTest("compiler/testData/codegen/box/casts/functions/reifiedAsFunKSmall.kt"); } + @Test @TestMetadata("reifiedIsFunKBig.kt") public void testReifiedIsFunKBig() throws Exception { runTest("compiler/testData/codegen/box/casts/functions/reifiedIsFunKBig.kt"); } + @Test @TestMetadata("reifiedIsFunKSmall.kt") public void testReifiedIsFunKSmall() throws Exception { runTest("compiler/testData/codegen/box/casts/functions/reifiedIsFunKSmall.kt"); } + @Test @TestMetadata("reifiedSafeAsFunKBig.kt") public void testReifiedSafeAsFunKBig() throws Exception { runTest("compiler/testData/codegen/box/casts/functions/reifiedSafeAsFunKBig.kt"); } + @Test @TestMetadata("reifiedSafeAsFunKSmall.kt") public void testReifiedSafeAsFunKSmall() throws Exception { runTest("compiler/testData/codegen/box/casts/functions/reifiedSafeAsFunKSmall.kt"); } + @Test @TestMetadata("safeAsFunKBig.kt") public void testSafeAsFunKBig() throws Exception { runTest("compiler/testData/codegen/box/casts/functions/safeAsFunKBig.kt"); } + @Test @TestMetadata("safeAsFunKSmall.kt") public void testSafeAsFunKSmall() throws Exception { runTest("compiler/testData/codegen/box/casts/functions/safeAsFunKSmall.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/casts/javaInterop") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class JavaInterop extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class JavaInterop { + @Test public void testAllFilesPresentInJavaInterop() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/javaInterop"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class LiteralExpressionAsGenericArgument extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class LiteralExpressionAsGenericArgument { + @Test public void testAllFilesPresentInLiteralExpressionAsGenericArgument() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("binaryExpressionCast.kt") public void testBinaryExpressionCast() throws Exception { runTest("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument/binaryExpressionCast.kt"); } + @Test @TestMetadata("labeledExpressionCast.kt") public void testLabeledExpressionCast() throws Exception { runTest("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument/labeledExpressionCast.kt"); } + @Test @TestMetadata("parenthesizedExpressionCast.kt") public void testParenthesizedExpressionCast() throws Exception { runTest("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument/parenthesizedExpressionCast.kt"); } + @Test @TestMetadata("superConstructor.kt") public void testSuperConstructor() throws Exception { runTest("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument/superConstructor.kt"); } + @Test @TestMetadata("unaryExpressionCast.kt") public void testUnaryExpressionCast() throws Exception { runTest("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument/unaryExpressionCast.kt"); } + @Test @TestMetadata("vararg.kt") public void testVararg() throws Exception { runTest("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument/vararg.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/casts/mutableCollections") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class MutableCollections extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class MutableCollections { + @Test public void testAllFilesPresentInMutableCollections() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/mutableCollections"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("asWithMutable.kt") public void testAsWithMutable() throws Exception { runTest("compiler/testData/codegen/box/casts/mutableCollections/asWithMutable.kt"); } + @Test @TestMetadata("isWithMutable.kt") public void testIsWithMutable() throws Exception { runTest("compiler/testData/codegen/box/casts/mutableCollections/isWithMutable.kt"); } + @Test @TestMetadata("reifiedAsWithMutable.kt") public void testReifiedAsWithMutable() throws Exception { runTest("compiler/testData/codegen/box/casts/mutableCollections/reifiedAsWithMutable.kt"); } + @Test @TestMetadata("reifiedIsWithMutable.kt") public void testReifiedIsWithMutable() throws Exception { runTest("compiler/testData/codegen/box/casts/mutableCollections/reifiedIsWithMutable.kt"); } + @Test @TestMetadata("reifiedSafeAsWithMutable.kt") public void testReifiedSafeAsWithMutable() throws Exception { runTest("compiler/testData/codegen/box/casts/mutableCollections/reifiedSafeAsWithMutable.kt"); } + @Test @TestMetadata("safeAsWithMutable.kt") public void testSafeAsWithMutable() throws Exception { runTest("compiler/testData/codegen/box/casts/mutableCollections/safeAsWithMutable.kt"); } + @Test @TestMetadata("weirdMutableCasts.kt") public void testWeirdMutableCasts() throws Exception { runTest("compiler/testData/codegen/box/casts/mutableCollections/weirdMutableCasts.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/casts/nativeCCEMessage") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NativeCCEMessage extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NativeCCEMessage { + @Test public void testAllFilesPresentInNativeCCEMessage() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/nativeCCEMessage"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/checkcastOptimization") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class CheckcastOptimization extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class CheckcastOptimization { + @Test public void testAllFilesPresentInCheckcastOptimization() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/checkcastOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt19128.kt") public void testKt19128() throws Exception { runTest("compiler/testData/codegen/box/checkcastOptimization/kt19128.kt"); } + @Test @TestMetadata("kt19246.kt") public void testKt19246() throws Exception { runTest("compiler/testData/codegen/box/checkcastOptimization/kt19246.kt"); } + @Test @TestMetadata("kt47851.kt") public void testKt47851() throws Exception { runTest("compiler/testData/codegen/box/checkcastOptimization/kt47851.kt"); } + @Test @TestMetadata("kt50215.kt") public void testKt50215() throws Exception { runTest("compiler/testData/codegen/box/checkcastOptimization/kt50215.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/classLiteral") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ClassLiteral extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ClassLiteral { + @Test public void testAllFilesPresentInClassLiteral() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("bareArray.kt") public void testBareArray() throws Exception { runTest("compiler/testData/codegen/box/classLiteral/bareArray.kt"); } + @Test @TestMetadata("classEquality.kt") public void testClassEquality() throws Exception { runTest("compiler/testData/codegen/box/classLiteral/classEquality.kt"); } + @Test @TestMetadata("primitiveClassEquality.kt") public void testPrimitiveClassEquality() throws Exception { runTest("compiler/testData/codegen/box/classLiteral/primitiveClassEquality.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/classLiteral/bound") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Bound extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Bound { + @Test public void testAllFilesPresentInBound() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/bound"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("primitives.kt") public void testPrimitives() throws Exception { runTest("compiler/testData/codegen/box/classLiteral/bound/primitives.kt"); } + @Test @TestMetadata("sideEffect.kt") public void testSideEffect() throws Exception { runTest("compiler/testData/codegen/box/classLiteral/bound/sideEffect.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/classLiteral/bound/simple.kt"); } + @Test @TestMetadata("smartCast.kt") public void testSmartCast() throws Exception { runTest("compiler/testData/codegen/box/classLiteral/bound/smartCast.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/classLiteral/java") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Java extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Java { + @Test public void testAllFilesPresentInJava() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/java"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/classes") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Classes extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Classes { + @Test public void testAllFilesPresentInClasses() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("boxPrimitiveTypeInClinitOfClassObject.kt") public void testBoxPrimitiveTypeInClinitOfClassObject() throws Exception { runTest("compiler/testData/codegen/box/classes/boxPrimitiveTypeInClinitOfClassObject.kt"); } + @Test @TestMetadata("classNamedAsOldPackageFacade.kt") public void testClassNamedAsOldPackageFacade() throws Exception { runTest("compiler/testData/codegen/box/classes/classNamedAsOldPackageFacade.kt"); } + @Test @TestMetadata("classObject.kt") public void testClassObject() throws Exception { runTest("compiler/testData/codegen/box/classes/classObject.kt"); } + @Test @TestMetadata("classObjectAsExtensionReceiver.kt") public void testClassObjectAsExtensionReceiver() throws Exception { runTest("compiler/testData/codegen/box/classes/classObjectAsExtensionReceiver.kt"); } + @Test @TestMetadata("classObjectAsStaticInitializer.kt") public void testClassObjectAsStaticInitializer() throws Exception { runTest("compiler/testData/codegen/box/classes/classObjectAsStaticInitializer.kt"); } + @Test @TestMetadata("classObjectField.kt") public void testClassObjectField() throws Exception { runTest("compiler/testData/codegen/box/classes/classObjectField.kt"); } + @Test @TestMetadata("classObjectInTrait.kt") public void testClassObjectInTrait() throws Exception { runTest("compiler/testData/codegen/box/classes/classObjectInTrait.kt"); } + @Test @TestMetadata("classObjectNotOfEnum.kt") public void testClassObjectNotOfEnum() throws Exception { runTest("compiler/testData/codegen/box/classes/classObjectNotOfEnum.kt"); } + @Test @TestMetadata("classObjectWithPrivateGenericMember.kt") public void testClassObjectWithPrivateGenericMember() throws Exception { runTest("compiler/testData/codegen/box/classes/classObjectWithPrivateGenericMember.kt"); } + @Test @TestMetadata("classObjectsWithParentClasses.kt") public void testClassObjectsWithParentClasses() throws Exception { runTest("compiler/testData/codegen/box/classes/classObjectsWithParentClasses.kt"); } + @Test @TestMetadata("comanionObjectFieldVsClassField.kt") public void testComanionObjectFieldVsClassField() throws Exception { runTest("compiler/testData/codegen/box/classes/comanionObjectFieldVsClassField.kt"); } + @Test @TestMetadata("defaultObjectSameNamesAsInOuter.kt") public void testDefaultObjectSameNamesAsInOuter() throws Exception { runTest("compiler/testData/codegen/box/classes/defaultObjectSameNamesAsInOuter.kt"); } + @Test @TestMetadata("delegateConstructorCallWithKeywords.kt") public void testDelegateConstructorCallWithKeywords() throws Exception { runTest("compiler/testData/codegen/box/classes/delegateConstructorCallWithKeywords.kt"); } + @Test @TestMetadata("delegation2.kt") public void testDelegation2() throws Exception { runTest("compiler/testData/codegen/box/classes/delegation2.kt"); } + @Test @TestMetadata("delegation3.kt") public void testDelegation3() throws Exception { runTest("compiler/testData/codegen/box/classes/delegation3.kt"); } + @Test @TestMetadata("delegation4.kt") public void testDelegation4() throws Exception { runTest("compiler/testData/codegen/box/classes/delegation4.kt"); } + @Test @TestMetadata("delegationGenericArg.kt") public void testDelegationGenericArg() throws Exception { runTest("compiler/testData/codegen/box/classes/delegationGenericArg.kt"); } + @Test @TestMetadata("delegationGenericArgUpperBound.kt") public void testDelegationGenericArgUpperBound() throws Exception { runTest("compiler/testData/codegen/box/classes/delegationGenericArgUpperBound.kt"); } + @Test @TestMetadata("delegationGenericLongArg.kt") public void testDelegationGenericLongArg() throws Exception { runTest("compiler/testData/codegen/box/classes/delegationGenericLongArg.kt"); } + @Test @TestMetadata("delegationMethodsWithArgs.kt") public void testDelegationMethodsWithArgs() throws Exception { runTest("compiler/testData/codegen/box/classes/delegationMethodsWithArgs.kt"); } + @Test @TestMetadata("exceptionConstructor.kt") public void testExceptionConstructor() throws Exception { runTest("compiler/testData/codegen/box/classes/exceptionConstructor.kt"); } + @Test @TestMetadata("extensionFunWithDefaultParam.kt") public void testExtensionFunWithDefaultParam() throws Exception { runTest("compiler/testData/codegen/box/classes/extensionFunWithDefaultParam.kt"); } + @Test @TestMetadata("extensionOnNamedClassObject.kt") public void testExtensionOnNamedClassObject() throws Exception { runTest("compiler/testData/codegen/box/classes/extensionOnNamedClassObject.kt"); } + @Test @TestMetadata("funDelegation.kt") public void testFunDelegation() throws Exception { runTest("compiler/testData/codegen/box/classes/funDelegation.kt"); } + @Test @TestMetadata("implementComparableInSubclass.kt") public void testImplementComparableInSubclass() throws Exception { runTest("compiler/testData/codegen/box/classes/implementComparableInSubclass.kt"); } + @Test @TestMetadata("inheritSetAndHashSet.kt") public void testInheritSetAndHashSet() throws Exception { runTest("compiler/testData/codegen/box/classes/inheritSetAndHashSet.kt"); } + @Test @TestMetadata("inheritance.kt") public void testInheritance() throws Exception { runTest("compiler/testData/codegen/box/classes/inheritance.kt"); } + @Test @TestMetadata("inheritedInnerClass.kt") public void testInheritedInnerClass() throws Exception { runTest("compiler/testData/codegen/box/classes/inheritedInnerClass.kt"); } + @Test @TestMetadata("inheritedMethod.kt") public void testInheritedMethod() throws Exception { runTest("compiler/testData/codegen/box/classes/inheritedMethod.kt"); } + @Test @TestMetadata("initializerBlock.kt") public void testInitializerBlock() throws Exception { runTest("compiler/testData/codegen/box/classes/initializerBlock.kt"); } + @Test @TestMetadata("initializerBlockDImpl.kt") public void testInitializerBlockDImpl() throws Exception { runTest("compiler/testData/codegen/box/classes/initializerBlockDImpl.kt"); } + @Test @TestMetadata("initializerBlockResetToDefault.kt") public void testInitializerBlockResetToDefault() throws Exception { runTest("compiler/testData/codegen/box/classes/initializerBlockResetToDefault.kt"); } + @Test @TestMetadata("innerClass.kt") public void testInnerClass() throws Exception { runTest("compiler/testData/codegen/box/classes/innerClass.kt"); } + @Test @TestMetadata("kt1018.kt") public void testKt1018() throws Exception { runTest("compiler/testData/codegen/box/classes/kt1018.kt"); } + @Test @TestMetadata("kt1157.kt") public void testKt1157() throws Exception { runTest("compiler/testData/codegen/box/classes/kt1157.kt"); } + @Test @TestMetadata("kt1247.kt") public void testKt1247() throws Exception { runTest("compiler/testData/codegen/box/classes/kt1247.kt"); } + @Test @TestMetadata("kt1345.kt") public void testKt1345() throws Exception { runTest("compiler/testData/codegen/box/classes/kt1345.kt"); } + @Test @TestMetadata("kt1439.kt") public void testKt1439() throws Exception { runTest("compiler/testData/codegen/box/classes/kt1439.kt"); } + @Test @TestMetadata("kt1535.kt") public void testKt1535() throws Exception { runTest("compiler/testData/codegen/box/classes/kt1535.kt"); } + @Test @TestMetadata("kt1538.kt") public void testKt1538() throws Exception { runTest("compiler/testData/codegen/box/classes/kt1538.kt"); } + @Test @TestMetadata("kt1578.kt") public void testKt1578() throws Exception { runTest("compiler/testData/codegen/box/classes/kt1578.kt"); } + @Test @TestMetadata("kt1611.kt") public void testKt1611() throws Exception { runTest("compiler/testData/codegen/box/classes/kt1611.kt"); } + @Test @TestMetadata("kt1721.kt") public void testKt1721() throws Exception { runTest("compiler/testData/codegen/box/classes/kt1721.kt"); } + @Test @TestMetadata("kt1726.kt") public void testKt1726() throws Exception { runTest("compiler/testData/codegen/box/classes/kt1726.kt"); } + @Test @TestMetadata("kt1759.kt") public void testKt1759() throws Exception { runTest("compiler/testData/codegen/box/classes/kt1759.kt"); } + @Test @TestMetadata("kt1891.kt") public void testKt1891() throws Exception { runTest("compiler/testData/codegen/box/classes/kt1891.kt"); } + @Test @TestMetadata("kt1918.kt") public void testKt1918() throws Exception { runTest("compiler/testData/codegen/box/classes/kt1918.kt"); } + @Test @TestMetadata("kt1976.kt") public void testKt1976() throws Exception { runTest("compiler/testData/codegen/box/classes/kt1976.kt"); } + @Test @TestMetadata("kt1980.kt") public void testKt1980() throws Exception { runTest("compiler/testData/codegen/box/classes/kt1980.kt"); } + @Test @TestMetadata("kt2224.kt") public void testKt2224() throws Exception { runTest("compiler/testData/codegen/box/classes/kt2224.kt"); } + @Test @TestMetadata("kt2384.kt") public void testKt2384() throws Exception { runTest("compiler/testData/codegen/box/classes/kt2384.kt"); } + @Test @TestMetadata("kt2390.kt") public void testKt2390() throws Exception { runTest("compiler/testData/codegen/box/classes/kt2390.kt"); } + @Test @TestMetadata("kt2391.kt") public void testKt2391() throws Exception { runTest("compiler/testData/codegen/box/classes/kt2391.kt"); } + @Test @TestMetadata("kt2417.kt") public void testKt2417() throws Exception { runTest("compiler/testData/codegen/box/classes/kt2417.kt"); } + @Test @TestMetadata("kt2477.kt") public void testKt2477() throws Exception { runTest("compiler/testData/codegen/box/classes/kt2477.kt"); } + @Test @TestMetadata("kt2480.kt") public void testKt2480() throws Exception { runTest("compiler/testData/codegen/box/classes/kt2480.kt"); } + @Test @TestMetadata("kt2482.kt") public void testKt2482() throws Exception { runTest("compiler/testData/codegen/box/classes/kt2482.kt"); } + @Test @TestMetadata("kt2485.kt") public void testKt2485() throws Exception { runTest("compiler/testData/codegen/box/classes/kt2485.kt"); } + @Test @TestMetadata("kt249.kt") public void testKt249() throws Exception { runTest("compiler/testData/codegen/box/classes/kt249.kt"); } + @Test @TestMetadata("kt2532.kt") public void testKt2532() throws Exception { runTest("compiler/testData/codegen/box/classes/kt2532.kt"); } + @Test @TestMetadata("kt2566.kt") public void testKt2566() throws Exception { runTest("compiler/testData/codegen/box/classes/kt2566.kt"); } + @Test @TestMetadata("kt2566_2.kt") public void testKt2566_2() throws Exception { runTest("compiler/testData/codegen/box/classes/kt2566_2.kt"); } + @Test @TestMetadata("kt2607.kt") public void testKt2607() throws Exception { runTest("compiler/testData/codegen/box/classes/kt2607.kt"); } + @Test @TestMetadata("kt2626.kt") public void testKt2626() throws Exception { runTest("compiler/testData/codegen/box/classes/kt2626.kt"); } + @Test @TestMetadata("kt2711.kt") public void testKt2711() throws Exception { runTest("compiler/testData/codegen/box/classes/kt2711.kt"); } + @Test @TestMetadata("kt2784.kt") public void testKt2784() throws Exception { runTest("compiler/testData/codegen/box/classes/kt2784.kt"); } + @Test @TestMetadata("kt285.kt") public void testKt285() throws Exception { runTest("compiler/testData/codegen/box/classes/kt285.kt"); } + @Test @TestMetadata("kt3001.kt") public void testKt3001() throws Exception { runTest("compiler/testData/codegen/box/classes/kt3001.kt"); } + @Test @TestMetadata("kt3114.kt") public void testKt3114() throws Exception { runTest("compiler/testData/codegen/box/classes/kt3114.kt"); } + @Test @TestMetadata("kt3414.kt") public void testKt3414() throws Exception { runTest("compiler/testData/codegen/box/classes/kt3414.kt"); } + @Test @TestMetadata("kt343.kt") public void testKt343() throws Exception { runTest("compiler/testData/codegen/box/classes/kt343.kt"); } + @Test @TestMetadata("kt3546.kt") public void testKt3546() throws Exception { runTest("compiler/testData/codegen/box/classes/kt3546.kt"); } + @Test @TestMetadata("kt40332.kt") public void testKt40332() throws Exception { runTest("compiler/testData/codegen/box/classes/kt40332.kt"); } + @Test @TestMetadata("kt454.kt") public void testKt454() throws Exception { runTest("compiler/testData/codegen/box/classes/kt454.kt"); } + @Test @TestMetadata("kt471.kt") public void testKt471() throws Exception { runTest("compiler/testData/codegen/box/classes/kt471.kt"); } + @Test @TestMetadata("kt48.kt") public void testKt48() throws Exception { runTest("compiler/testData/codegen/box/classes/kt48.kt"); } + @Test @TestMetadata("kt496.kt") public void testKt496() throws Exception { runTest("compiler/testData/codegen/box/classes/kt496.kt"); } + @Test @TestMetadata("kt500.kt") public void testKt500() throws Exception { runTest("compiler/testData/codegen/box/classes/kt500.kt"); } + @Test @TestMetadata("kt501.kt") public void testKt501() throws Exception { runTest("compiler/testData/codegen/box/classes/kt501.kt"); } + @Test @TestMetadata("kt504.kt") public void testKt504() throws Exception { runTest("compiler/testData/codegen/box/classes/kt504.kt"); } + @Test @TestMetadata("kt508.kt") public void testKt508() throws Exception { runTest("compiler/testData/codegen/box/classes/kt508.kt"); } + @Test @TestMetadata("kt5347.kt") public void testKt5347() throws Exception { runTest("compiler/testData/codegen/box/classes/kt5347.kt"); } + @Test @TestMetadata("kt6136.kt") public void testKt6136() throws Exception { runTest("compiler/testData/codegen/box/classes/kt6136.kt"); } + @Test @TestMetadata("kt633.kt") public void testKt633() throws Exception { runTest("compiler/testData/codegen/box/classes/kt633.kt"); } + @Test @TestMetadata("kt6816.kt") public void testKt6816() throws Exception { runTest("compiler/testData/codegen/box/classes/kt6816.kt"); } + @Test @TestMetadata("kt707.kt") public void testKt707() throws Exception { runTest("compiler/testData/codegen/box/classes/kt707.kt"); } + @Test @TestMetadata("kt723.kt") public void testKt723() throws Exception { runTest("compiler/testData/codegen/box/classes/kt723.kt"); } + @Test @TestMetadata("kt725.kt") public void testKt725() throws Exception { runTest("compiler/testData/codegen/box/classes/kt725.kt"); } + @Test @TestMetadata("kt8011.kt") public void testKt8011() throws Exception { runTest("compiler/testData/codegen/box/classes/kt8011.kt"); } + @Test @TestMetadata("kt8011a.kt") public void testKt8011a() throws Exception { runTest("compiler/testData/codegen/box/classes/kt8011a.kt"); } + @Test @TestMetadata("kt940.kt") public void testKt940() throws Exception { runTest("compiler/testData/codegen/box/classes/kt940.kt"); } + @Test @TestMetadata("kt9642.kt") public void testKt9642() throws Exception { runTest("compiler/testData/codegen/box/classes/kt9642.kt"); } + @Test @TestMetadata("namedClassObject.kt") public void testNamedClassObject() throws Exception { runTest("compiler/testData/codegen/box/classes/namedClassObject.kt"); } + @Test @TestMetadata("outerThis.kt") public void testOuterThis() throws Exception { runTest("compiler/testData/codegen/box/classes/outerThis.kt"); } + @Test @TestMetadata("overloadBinaryOperator.kt") public void testOverloadBinaryOperator() throws Exception { runTest("compiler/testData/codegen/box/classes/overloadBinaryOperator.kt"); } + @Test @TestMetadata("overloadPlusAssign.kt") public void testOverloadPlusAssign() throws Exception { runTest("compiler/testData/codegen/box/classes/overloadPlusAssign.kt"); } + @Test @TestMetadata("overloadPlusAssignReturn.kt") public void testOverloadPlusAssignReturn() throws Exception { runTest("compiler/testData/codegen/box/classes/overloadPlusAssignReturn.kt"); } + @Test @TestMetadata("overloadPlusToPlusAssign.kt") public void testOverloadPlusToPlusAssign() throws Exception { runTest("compiler/testData/codegen/box/classes/overloadPlusToPlusAssign.kt"); } + @Test @TestMetadata("overloadUnaryOperator.kt") public void testOverloadUnaryOperator() throws Exception { runTest("compiler/testData/codegen/box/classes/overloadUnaryOperator.kt"); } + @Test @TestMetadata("privateOuterFunctions.kt") public void testPrivateOuterFunctions() throws Exception { runTest("compiler/testData/codegen/box/classes/privateOuterFunctions.kt"); } + @Test @TestMetadata("privateOuterProperty.kt") public void testPrivateOuterProperty() throws Exception { runTest("compiler/testData/codegen/box/classes/privateOuterProperty.kt"); } + @Test @TestMetadata("privateToThis.kt") public void testPrivateToThis() throws Exception { runTest("compiler/testData/codegen/box/classes/privateToThis.kt"); } + @Test @TestMetadata("propertyDelegation.kt") public void testPropertyDelegation() throws Exception { runTest("compiler/testData/codegen/box/classes/propertyDelegation.kt"); } + @Test @TestMetadata("propertyInInitializer.kt") public void testPropertyInInitializer() throws Exception { runTest("compiler/testData/codegen/box/classes/propertyInInitializer.kt"); } + @Test @TestMetadata("quotedClassName.kt") public void testQuotedClassName() throws Exception { runTest("compiler/testData/codegen/box/classes/quotedClassName.kt"); } + @Test @TestMetadata("rightHandOverride.kt") public void testRightHandOverride() throws Exception { runTest("compiler/testData/codegen/box/classes/rightHandOverride.kt"); } + @Test @TestMetadata("selfcreate.kt") public void testSelfcreate() throws Exception { runTest("compiler/testData/codegen/box/classes/selfcreate.kt"); } + @Test @TestMetadata("simpleBox.kt") public void testSimpleBox() throws Exception { runTest("compiler/testData/codegen/box/classes/simpleBox.kt"); } + @Test @TestMetadata("superConstructorCallWithComplexArg.kt") public void testSuperConstructorCallWithComplexArg() throws Exception { runTest("compiler/testData/codegen/box/classes/superConstructorCallWithComplexArg.kt"); } + @Test @TestMetadata("typedDelegation.kt") public void testTypedDelegation() throws Exception { runTest("compiler/testData/codegen/box/classes/typedDelegation.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/classes/inner") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Inner extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Inner { + @Test public void testAllFilesPresentInInner() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes/inner"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("extensionWithOuter.kt") public void testExtensionWithOuter() throws Exception { runTest("compiler/testData/codegen/box/classes/inner/extensionWithOuter.kt"); } + @Test @TestMetadata("instantiateInDerived.kt") public void testInstantiateInDerived() throws Exception { runTest("compiler/testData/codegen/box/classes/inner/instantiateInDerived.kt"); } + @Test @TestMetadata("instantiateInDerivedLabeled.kt") public void testInstantiateInDerivedLabeled() throws Exception { runTest("compiler/testData/codegen/box/classes/inner/instantiateInDerivedLabeled.kt"); } + @Test @TestMetadata("instantiateInSameClass.kt") public void testInstantiateInSameClass() throws Exception { runTest("compiler/testData/codegen/box/classes/inner/instantiateInSameClass.kt"); } + @Test @TestMetadata("kt6708.kt") public void testKt6708() throws Exception { runTest("compiler/testData/codegen/box/classes/inner/kt6708.kt"); } + @Test @TestMetadata("properOuter.kt") public void testProperOuter() throws Exception { runTest("compiler/testData/codegen/box/classes/inner/properOuter.kt"); } + @Test @TestMetadata("properSuperLinking.kt") public void testProperSuperLinking() throws Exception { runTest("compiler/testData/codegen/box/classes/inner/properSuperLinking.kt"); @@ -4020,589 +4544,679 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/closures") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Closures extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Closures { + @Test public void testAllFilesPresentInClosures() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("anonymousObjectAsLastExpressionInLambda.kt") public void testAnonymousObjectAsLastExpressionInLambda() throws Exception { runTest("compiler/testData/codegen/box/closures/anonymousObjectAsLastExpressionInLambda.kt"); } + @Test @TestMetadata("captureExtensionReceiver.kt") public void testCaptureExtensionReceiver() throws Exception { runTest("compiler/testData/codegen/box/closures/captureExtensionReceiver.kt"); } + @Test @TestMetadata("captureExtensionReceiverX2.kt") public void testCaptureExtensionReceiverX2() throws Exception { runTest("compiler/testData/codegen/box/closures/captureExtensionReceiverX2.kt"); } + @Test @TestMetadata("capturedLocalGenericFun.kt") public void testCapturedLocalGenericFun() throws Exception { runTest("compiler/testData/codegen/box/closures/capturedLocalGenericFun.kt"); } + @Test @TestMetadata("closureCapturingGenericParam.kt") public void testClosureCapturingGenericParam() throws Exception { runTest("compiler/testData/codegen/box/closures/closureCapturingGenericParam.kt"); } + @Test @TestMetadata("closureInsideConstrucor.kt") public void testClosureInsideConstrucor() throws Exception { runTest("compiler/testData/codegen/box/closures/closureInsideConstrucor.kt"); } + @Test @TestMetadata("closureOnTopLevel1.kt") public void testClosureOnTopLevel1() throws Exception { runTest("compiler/testData/codegen/box/closures/closureOnTopLevel1.kt"); } + @Test @TestMetadata("closureOnTopLevel2.kt") public void testClosureOnTopLevel2() throws Exception { runTest("compiler/testData/codegen/box/closures/closureOnTopLevel2.kt"); } + @Test @TestMetadata("closureWithParameter.kt") public void testClosureWithParameter() throws Exception { runTest("compiler/testData/codegen/box/closures/closureWithParameter.kt"); } + @Test @TestMetadata("closureWithParameterAndBoxing.kt") public void testClosureWithParameterAndBoxing() throws Exception { runTest("compiler/testData/codegen/box/closures/closureWithParameterAndBoxing.kt"); } + @Test @TestMetadata("crossinlineLocalDeclaration.kt") public void testCrossinlineLocalDeclaration() throws Exception { runTest("compiler/testData/codegen/box/closures/crossinlineLocalDeclaration.kt"); } + @Test @TestMetadata("doubleEnclosedLocalVariable.kt") public void testDoubleEnclosedLocalVariable() throws Exception { runTest("compiler/testData/codegen/box/closures/doubleEnclosedLocalVariable.kt"); } + @Test @TestMetadata("enclosingLocalVariable.kt") public void testEnclosingLocalVariable() throws Exception { runTest("compiler/testData/codegen/box/closures/enclosingLocalVariable.kt"); } + @Test @TestMetadata("enclosingThis.kt") public void testEnclosingThis() throws Exception { runTest("compiler/testData/codegen/box/closures/enclosingThis.kt"); } + @Test @TestMetadata("extensionClosure.kt") public void testExtensionClosure() throws Exception { runTest("compiler/testData/codegen/box/closures/extensionClosure.kt"); } + @Test @TestMetadata("kt10044.kt") public void testKt10044() throws Exception { runTest("compiler/testData/codegen/box/closures/kt10044.kt"); } + @Test @TestMetadata("kt11634.kt") public void testKt11634() throws Exception { runTest("compiler/testData/codegen/box/closures/kt11634.kt"); } + @Test @TestMetadata("kt11634_2.kt") public void testKt11634_2() throws Exception { runTest("compiler/testData/codegen/box/closures/kt11634_2.kt"); } + @Test @TestMetadata("kt11634_3.kt") public void testKt11634_3() throws Exception { runTest("compiler/testData/codegen/box/closures/kt11634_3.kt"); } + @Test @TestMetadata("kt11634_4.kt") public void testKt11634_4() throws Exception { runTest("compiler/testData/codegen/box/closures/kt11634_4.kt"); } + @Test @TestMetadata("kt19389.kt") public void testKt19389() throws Exception { runTest("compiler/testData/codegen/box/closures/kt19389.kt"); } + @Test @TestMetadata("kt19389_set.kt") public void testKt19389_set() throws Exception { runTest("compiler/testData/codegen/box/closures/kt19389_set.kt"); } + @Test @TestMetadata("kt2151.kt") public void testKt2151() throws Exception { runTest("compiler/testData/codegen/box/closures/kt2151.kt"); } + @Test @TestMetadata("kt3152.kt") public void testKt3152() throws Exception { runTest("compiler/testData/codegen/box/closures/kt3152.kt"); } + @Test @TestMetadata("kt3523.kt") public void testKt3523() throws Exception { runTest("compiler/testData/codegen/box/closures/kt3523.kt"); } + @Test @TestMetadata("kt3738.kt") public void testKt3738() throws Exception { runTest("compiler/testData/codegen/box/closures/kt3738.kt"); } + @Test @TestMetadata("kt3905.kt") public void testKt3905() throws Exception { runTest("compiler/testData/codegen/box/closures/kt3905.kt"); } + @Test @TestMetadata("kt4106.kt") public void testKt4106() throws Exception { runTest("compiler/testData/codegen/box/closures/kt4106.kt"); } + @Test @TestMetadata("kt4137.kt") public void testKt4137() throws Exception { runTest("compiler/testData/codegen/box/closures/kt4137.kt"); } + @Test @TestMetadata("kt47840.kt") public void testKt47840() throws Exception { runTest("compiler/testData/codegen/box/closures/kt47840.kt"); } + @Test @TestMetadata("kt47894_inlineFunWithObjectWithNothing.kt") public void testKt47894_inlineFunWithObjectWithNothing() throws Exception { runTest("compiler/testData/codegen/box/closures/kt47894_inlineFunWithObjectWithNothing.kt"); } + @Test @TestMetadata("kt5589.kt") public void testKt5589() throws Exception { runTest("compiler/testData/codegen/box/closures/kt5589.kt"); } + @Test @TestMetadata("localClassFunClosure.kt") public void testLocalClassFunClosure() throws Exception { runTest("compiler/testData/codegen/box/closures/localClassFunClosure.kt"); } + @Test @TestMetadata("localClassLambdaClosure.kt") public void testLocalClassLambdaClosure() throws Exception { runTest("compiler/testData/codegen/box/closures/localClassLambdaClosure.kt"); } + @Test @TestMetadata("localFunInInit.kt") public void testLocalFunInInit() throws Exception { runTest("compiler/testData/codegen/box/closures/localFunInInit.kt"); } + @Test @TestMetadata("localFunctionInFunction.kt") public void testLocalFunctionInFunction() throws Exception { runTest("compiler/testData/codegen/box/closures/localFunctionInFunction.kt"); } + @Test @TestMetadata("localFunctionInInitBlock.kt") public void testLocalFunctionInInitBlock() throws Exception { runTest("compiler/testData/codegen/box/closures/localFunctionInInitBlock.kt"); } + @Test @TestMetadata("localFunctionInInitializer.kt") public void testLocalFunctionInInitializer() throws Exception { runTest("compiler/testData/codegen/box/closures/localFunctionInInitializer.kt"); } + @Test @TestMetadata("localGenericFun.kt") public void testLocalGenericFun() throws Exception { runTest("compiler/testData/codegen/box/closures/localGenericFun.kt"); } + @Test @TestMetadata("localReturn.kt") public void testLocalReturn() throws Exception { runTest("compiler/testData/codegen/box/closures/localReturn.kt"); } + @Test @TestMetadata("localReturnWithAutolabel.kt") public void testLocalReturnWithAutolabel() throws Exception { runTest("compiler/testData/codegen/box/closures/localReturnWithAutolabel.kt"); } + @Test @TestMetadata("recursiveClosure.kt") public void testRecursiveClosure() throws Exception { runTest("compiler/testData/codegen/box/closures/recursiveClosure.kt"); } + @Test @TestMetadata("simplestClosure.kt") public void testSimplestClosure() throws Exception { runTest("compiler/testData/codegen/box/closures/simplestClosure.kt"); } + @Test @TestMetadata("simplestClosureAndBoxing.kt") public void testSimplestClosureAndBoxing() throws Exception { runTest("compiler/testData/codegen/box/closures/simplestClosureAndBoxing.kt"); } + @Test @TestMetadata("subclosuresWithinInitializers.kt") public void testSubclosuresWithinInitializers() throws Exception { runTest("compiler/testData/codegen/box/closures/subclosuresWithinInitializers.kt"); } + @Test @TestMetadata("underscoreParameters.kt") public void testUnderscoreParameters() throws Exception { runTest("compiler/testData/codegen/box/closures/underscoreParameters.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/closures/captureInSuperConstructorCall") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class CaptureInSuperConstructorCall extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class CaptureInSuperConstructorCall { + @Test public void testAllFilesPresentInCaptureInSuperConstructorCall() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureInSuperConstructorCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("constructorParameterAndLocalCapturedInLambdaInLocalClass.kt") public void testConstructorParameterAndLocalCapturedInLambdaInLocalClass() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/constructorParameterAndLocalCapturedInLambdaInLocalClass.kt"); } + @Test @TestMetadata("constructorParameterCapturedInLambdaInLocalClass.kt") public void testConstructorParameterCapturedInLambdaInLocalClass() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/constructorParameterCapturedInLambdaInLocalClass.kt"); } + @Test @TestMetadata("constructorParameterCapturedInLambdaInLocalClass2.kt") public void testConstructorParameterCapturedInLambdaInLocalClass2() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/constructorParameterCapturedInLambdaInLocalClass2.kt"); } + @Test @TestMetadata("kt13454.kt") public void testKt13454() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/kt13454.kt"); } + @Test @TestMetadata("kt14148.kt") public void testKt14148() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/kt14148.kt"); } + @Test @TestMetadata("kt4174.kt") public void testKt4174() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/kt4174.kt"); } + @Test @TestMetadata("kt4174a.kt") public void testKt4174a() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/kt4174a.kt"); } + @Test @TestMetadata("localCapturedInAnonymousObjectInLocalClass.kt") public void testLocalCapturedInAnonymousObjectInLocalClass() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/localCapturedInAnonymousObjectInLocalClass.kt"); } + @Test @TestMetadata("localCapturedInAnonymousObjectInLocalClass2.kt") public void testLocalCapturedInAnonymousObjectInLocalClass2() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/localCapturedInAnonymousObjectInLocalClass2.kt"); } + @Test @TestMetadata("localCapturedInLambdaInInnerClassInLocalClass.kt") public void testLocalCapturedInLambdaInInnerClassInLocalClass() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/localCapturedInLambdaInInnerClassInLocalClass.kt"); } + @Test @TestMetadata("localCapturedInLambdaInLocalClass.kt") public void testLocalCapturedInLambdaInLocalClass() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/localCapturedInLambdaInLocalClass.kt"); } + @Test @TestMetadata("localFunctionCapturedInLambda.kt") public void testLocalFunctionCapturedInLambda() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/localFunctionCapturedInLambda.kt"); } + @Test @TestMetadata("outerAndLocalCapturedInLocalClass.kt") public void testOuterAndLocalCapturedInLocalClass() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerAndLocalCapturedInLocalClass.kt"); } + @Test @TestMetadata("outerCapturedAsImplicitThisInBoundReference.kt") public void testOuterCapturedAsImplicitThisInBoundReference() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedAsImplicitThisInBoundReference.kt"); } + @Test @TestMetadata("outerCapturedInFunctionLiteral.kt") public void testOuterCapturedInFunctionLiteral() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInFunctionLiteral.kt"); } + @Test @TestMetadata("outerCapturedInInlineLambda.kt") public void testOuterCapturedInInlineLambda() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInInlineLambda.kt"); } + @Test @TestMetadata("outerCapturedInInlineLambda2.kt") public void testOuterCapturedInInlineLambda2() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInInlineLambda2.kt"); } + @Test @TestMetadata("outerCapturedInLambda.kt") public void testOuterCapturedInLambda() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInLambda.kt"); } + @Test @TestMetadata("outerCapturedInLambda2.kt") public void testOuterCapturedInLambda2() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInLambda2.kt"); } + @Test @TestMetadata("outerCapturedInLambdaInSecondaryConstructor.kt") public void testOuterCapturedInLambdaInSecondaryConstructor() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInLambdaInSecondaryConstructor.kt"); } + @Test @TestMetadata("outerCapturedInLambdaInSubExpression.kt") public void testOuterCapturedInLambdaInSubExpression() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInLambdaInSubExpression.kt"); } + @Test @TestMetadata("outerCapturedInLocalClass.kt") public void testOuterCapturedInLocalClass() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInLocalClass.kt"); } + @Test @TestMetadata("outerCapturedInNestedLambda.kt") public void testOuterCapturedInNestedLambda() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInNestedLambda.kt"); } + @Test @TestMetadata("outerCapturedInNestedObject.kt") public void testOuterCapturedInNestedObject() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInNestedObject.kt"); } + @Test @TestMetadata("outerCapturedInObject.kt") public void testOuterCapturedInObject() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInObject.kt"); } + @Test @TestMetadata("outerCapturedInObject2.kt") public void testOuterCapturedInObject2() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInObject2.kt"); } + @Test @TestMetadata("outerCapturedInPrimaryConstructorDefaultParameter.kt") public void testOuterCapturedInPrimaryConstructorDefaultParameter() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInPrimaryConstructorDefaultParameter.kt"); } + @Test @TestMetadata("outerCapturedInSecondaryConstructorDefaultParameter.kt") public void testOuterCapturedInSecondaryConstructorDefaultParameter() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInSecondaryConstructorDefaultParameter.kt"); } + @Test @TestMetadata("outerEnumEntryCapturedInLambdaInInnerClass.kt") public void testOuterEnumEntryCapturedInLambdaInInnerClass() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerEnumEntryCapturedInLambdaInInnerClass.kt"); } + @Test @TestMetadata("properValueCapturedByClosure1.kt") public void testProperValueCapturedByClosure1() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/properValueCapturedByClosure1.kt"); } + @Test @TestMetadata("properValueCapturedByClosure2.kt") public void testProperValueCapturedByClosure2() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/properValueCapturedByClosure2.kt"); } + @Test @TestMetadata("referenceToCapturedVariablesInMultipleLambdas.kt") public void testReferenceToCapturedVariablesInMultipleLambdas() throws Exception { runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/referenceToCapturedVariablesInMultipleLambdas.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/closures/captureOuterProperty") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class CaptureOuterProperty extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class CaptureOuterProperty { + @Test public void testAllFilesPresentInCaptureOuterProperty() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureOuterProperty"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("captureFunctionInProperty.kt") public void testCaptureFunctionInProperty() throws Exception { runTest("compiler/testData/codegen/box/closures/captureOuterProperty/captureFunctionInProperty.kt"); } + @Test @TestMetadata("inFunction.kt") public void testInFunction() throws Exception { runTest("compiler/testData/codegen/box/closures/captureOuterProperty/inFunction.kt"); } + @Test @TestMetadata("inProperty.kt") public void testInProperty() throws Exception { runTest("compiler/testData/codegen/box/closures/captureOuterProperty/inProperty.kt"); } + @Test @TestMetadata("inPropertyDeepObjectChain.kt") public void testInPropertyDeepObjectChain() throws Exception { runTest("compiler/testData/codegen/box/closures/captureOuterProperty/inPropertyDeepObjectChain.kt"); } + @Test @TestMetadata("inPropertyFromSuperClass.kt") public void testInPropertyFromSuperClass() throws Exception { runTest("compiler/testData/codegen/box/closures/captureOuterProperty/inPropertyFromSuperClass.kt"); } + @Test @TestMetadata("inPropertyFromSuperSuperClass.kt") public void testInPropertyFromSuperSuperClass() throws Exception { runTest("compiler/testData/codegen/box/closures/captureOuterProperty/inPropertyFromSuperSuperClass.kt"); } + @Test @TestMetadata("kt4176.kt") public void testKt4176() throws Exception { runTest("compiler/testData/codegen/box/closures/captureOuterProperty/kt4176.kt"); } + @Test @TestMetadata("kt4656.kt") public void testKt4656() throws Exception { runTest("compiler/testData/codegen/box/closures/captureOuterProperty/kt4656.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/closures/capturedVarsOptimization") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class CapturedVarsOptimization extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class CapturedVarsOptimization { + @Test public void testAllFilesPresentInCapturedVarsOptimization() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/capturedVarsOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("capturedInCrossinline.kt") public void testCapturedInCrossinline() throws Exception { runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/capturedInCrossinline.kt"); } + @Test @TestMetadata("capturedInInlineOnlyAssign.kt") public void testCapturedInInlineOnlyAssign() throws Exception { runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/capturedInInlineOnlyAssign.kt"); } + @Test @TestMetadata("capturedInInlineOnlyCAO.kt") public void testCapturedInInlineOnlyCAO() throws Exception { runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/capturedInInlineOnlyCAO.kt"); } + @Test @TestMetadata("capturedInInlineOnlyIncrDecr.kt") public void testCapturedInInlineOnlyIncrDecr() throws Exception { runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/capturedInInlineOnlyIncrDecr.kt"); } + @Test @TestMetadata("capturedInInlineOnlyIndexedCAO.kt") public void testCapturedInInlineOnlyIndexedCAO() throws Exception { runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/capturedInInlineOnlyIndexedCAO.kt"); } + @Test @TestMetadata("capturedVarsOfSize2.kt") public void testCapturedVarsOfSize2() throws Exception { runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/capturedVarsOfSize2.kt"); } + @Test @TestMetadata("kt17200.kt") public void testKt17200() throws Exception { runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/kt17200.kt"); } + @Test @TestMetadata("kt17588.kt") public void testKt17588() throws Exception { runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/kt17588.kt"); } + @Test @TestMetadata("kt44347.kt") public void testKt44347() throws Exception { runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/kt44347.kt"); } + @Test @TestMetadata("kt45446.kt") public void testKt45446() throws Exception { runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/kt45446.kt"); } + @Test @TestMetadata("sharedSlotsWithCapturedVars.kt") public void testSharedSlotsWithCapturedVars() throws Exception { runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/sharedSlotsWithCapturedVars.kt"); } + @Test @TestMetadata("withCoroutines.kt") public void testWithCoroutines() throws Exception { runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/withCoroutines.kt"); } + @Test @TestMetadata("withCoroutinesNoStdLib.kt") public void testWithCoroutinesNoStdLib() throws Exception { runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/withCoroutinesNoStdLib.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/closures/closureInsideClosure") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ClosureInsideClosure extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ClosureInsideClosure { + @Test public void testAllFilesPresentInClosureInsideClosure() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/closureInsideClosure"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("localFunInsideLocalFun.kt") public void testLocalFunInsideLocalFun() throws Exception { runTest("compiler/testData/codegen/box/closures/closureInsideClosure/localFunInsideLocalFun.kt"); } + @Test @TestMetadata("localFunInsideLocalFunDifferentSignatures.kt") public void testLocalFunInsideLocalFunDifferentSignatures() throws Exception { runTest("compiler/testData/codegen/box/closures/closureInsideClosure/localFunInsideLocalFunDifferentSignatures.kt"); } + @Test @TestMetadata("propertyAndFunctionNameClash.kt") public void testPropertyAndFunctionNameClash() throws Exception { runTest("compiler/testData/codegen/box/closures/closureInsideClosure/propertyAndFunctionNameClash.kt"); } + @Test @TestMetadata("threeLevels.kt") public void testThreeLevels() throws Exception { runTest("compiler/testData/codegen/box/closures/closureInsideClosure/threeLevels.kt"); } + @Test @TestMetadata("threeLevelsDifferentSignatures.kt") public void testThreeLevelsDifferentSignatures() throws Exception { runTest("compiler/testData/codegen/box/closures/closureInsideClosure/threeLevelsDifferentSignatures.kt"); } + @Test @TestMetadata("varAsFunInsideLocalFun.kt") public void testVarAsFunInsideLocalFun() throws Exception { runTest("compiler/testData/codegen/box/closures/closureInsideClosure/varAsFunInsideLocalFun.kt"); @@ -4610,871 +5224,984 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/collectionLiterals") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class CollectionLiterals extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class CollectionLiterals { + @Test public void testAllFilesPresentInCollectionLiterals() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collectionLiterals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/collections") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Collections extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Collections { + @Test @TestMetadata("addCollectionStubWithCovariantOverride.kt") public void testAddCollectionStubWithCovariantOverride() throws Exception { runTest("compiler/testData/codegen/box/collections/addCollectionStubWithCovariantOverride.kt"); } + @Test public void testAllFilesPresentInCollections() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collections"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("inSetWithSmartCast.kt") public void testInSetWithSmartCast() throws Exception { runTest("compiler/testData/codegen/box/collections/inSetWithSmartCast.kt"); } + @Test @TestMetadata("inheritFromAbstractMutableListInt.kt") public void testInheritFromAbstractMutableListInt() throws Exception { runTest("compiler/testData/codegen/box/collections/inheritFromAbstractMutableListInt.kt"); } + @Test @TestMetadata("internalRemove.kt") public void testInternalRemove() throws Exception { runTest("compiler/testData/codegen/box/collections/internalRemove.kt"); } + @Test @TestMetadata("kt41123.kt") public void testKt41123() throws Exception { runTest("compiler/testData/codegen/box/collections/kt41123.kt"); } + @Test @TestMetadata("removeClash.kt") public void testRemoveClash() throws Exception { runTest("compiler/testData/codegen/box/collections/removeClash.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/companion") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Companion extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Companion { + @Test public void testAllFilesPresentInCompanion() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/companion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("delegatedPropertyOnCompanion.kt") public void testDelegatedPropertyOnCompanion() throws Exception { runTest("compiler/testData/codegen/box/companion/delegatedPropertyOnCompanion.kt"); } + @Test @TestMetadata("genericLambdaOnStringCompanion.kt") public void testGenericLambdaOnStringCompanion() throws Exception { runTest("compiler/testData/codegen/box/companion/genericLambdaOnStringCompanion.kt"); } + @Test @TestMetadata("inlineFunctionCompanionPropertyAccess.kt") public void testInlineFunctionCompanionPropertyAccess() throws Exception { runTest("compiler/testData/codegen/box/companion/inlineFunctionCompanionPropertyAccess.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/compatibility") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Compatibility extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Compatibility { + @Test public void testAllFilesPresentInCompatibility() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/compatibility"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("privateCompanionObject.kt") public void testPrivateCompanionObject() throws Exception { runTest("compiler/testData/codegen/box/compatibility/privateCompanionObject.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/constants") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Constants extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Constants { + @Test public void testAllFilesPresentInConstants() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constants"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("comparisonFalse.kt") public void testComparisonFalse() throws Exception { runTest("compiler/testData/codegen/box/constants/comparisonFalse.kt"); } + @Test @TestMetadata("constValFromAnotherModuleInConsVal.kt") public void testConstValFromAnotherModuleInConsVal() throws Exception { runTest("compiler/testData/codegen/box/constants/constValFromAnotherModuleInConsVal.kt"); } + @Test @TestMetadata("constantsInWhen.kt") public void testConstantsInWhen() throws Exception { runTest("compiler/testData/codegen/box/constants/constantsInWhen.kt"); } + @Test @TestMetadata("divisionByZero.kt") public void testDivisionByZero() throws Exception { runTest("compiler/testData/codegen/box/constants/divisionByZero.kt"); } + @Test @TestMetadata("doNotTriggerInit.kt") public void testDoNotTriggerInit() throws Exception { runTest("compiler/testData/codegen/box/constants/doNotTriggerInit.kt"); } + @Test @TestMetadata("float.kt") public void testFloat() throws Exception { runTest("compiler/testData/codegen/box/constants/float.kt"); } + @Test @TestMetadata("foldingBinaryOpsUnsigned.kt") public void testFoldingBinaryOpsUnsigned() throws Exception { runTest("compiler/testData/codegen/box/constants/foldingBinaryOpsUnsigned.kt"); } + @Test @TestMetadata("foldingBinaryOpsUnsignedConst.kt") public void testFoldingBinaryOpsUnsignedConst() throws Exception { runTest("compiler/testData/codegen/box/constants/foldingBinaryOpsUnsignedConst.kt"); } + @Test @TestMetadata("kt9532.kt") public void testKt9532() throws Exception { runTest("compiler/testData/codegen/box/constants/kt9532.kt"); } + @Test @TestMetadata("literalToLongConversion.kt") public void testLiteralToLongConversion() throws Exception { runTest("compiler/testData/codegen/box/constants/literalToLongConversion.kt"); } + @Test @TestMetadata("long.kt") public void testLong() throws Exception { runTest("compiler/testData/codegen/box/constants/long.kt"); } + @Test @TestMetadata("privateConst.kt") public void testPrivateConst() throws Exception { runTest("compiler/testData/codegen/box/constants/privateConst.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/constructor") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Constructor extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Constructor { + @Test public void testAllFilesPresentInConstructor() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constructor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/constructorCall") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ConstructorCall extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ConstructorCall { + @Test public void testAllFilesPresentInConstructorCall() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constructorCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/contracts") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Contracts extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Contracts { + @Test public void testAllFilesPresentInContracts() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/contracts"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("constructorArgument.kt") public void testConstructorArgument() throws Exception { runTest("compiler/testData/codegen/box/contracts/constructorArgument.kt"); } + @Test @TestMetadata("destructuredVariable.kt") public void testDestructuredVariable() throws Exception { runTest("compiler/testData/codegen/box/contracts/destructuredVariable.kt"); } + @Test @TestMetadata("exactlyOnceNotInline.kt") public void testExactlyOnceNotInline() throws Exception { runTest("compiler/testData/codegen/box/contracts/exactlyOnceNotInline.kt"); } + @Test @TestMetadata("exception.kt") public void testException() throws Exception { runTest("compiler/testData/codegen/box/contracts/exception.kt"); } + @Test @TestMetadata("fieldInConstructorParens.kt") public void testFieldInConstructorParens() throws Exception { runTest("compiler/testData/codegen/box/contracts/fieldInConstructorParens.kt"); } + @Test @TestMetadata("fieldReadInConstructor.kt") public void testFieldReadInConstructor() throws Exception { runTest("compiler/testData/codegen/box/contracts/fieldReadInConstructor.kt"); } + @Test @TestMetadata("forLoop.kt") public void testForLoop() throws Exception { runTest("compiler/testData/codegen/box/contracts/forLoop.kt"); } + @Test @TestMetadata("functionParameter.kt") public void testFunctionParameter() throws Exception { runTest("compiler/testData/codegen/box/contracts/functionParameter.kt"); } + @Test @TestMetadata("kt39374.kt") public void testKt39374() throws Exception { runTest("compiler/testData/codegen/box/contracts/kt39374.kt"); } + @Test @TestMetadata("kt45236.kt") public void testKt45236() throws Exception { runTest("compiler/testData/codegen/box/contracts/kt45236.kt"); } + @Test @TestMetadata("kt47168.kt") public void testKt47168() throws Exception { runTest("compiler/testData/codegen/box/contracts/kt47168.kt"); } + @Test @TestMetadata("kt47300.kt") public void testKt47300() throws Exception { runTest("compiler/testData/codegen/box/contracts/kt47300.kt"); } + @Test @TestMetadata("lambdaParameter.kt") public void testLambdaParameter() throws Exception { runTest("compiler/testData/codegen/box/contracts/lambdaParameter.kt"); } + @Test @TestMetadata("listAppend.kt") public void testListAppend() throws Exception { runTest("compiler/testData/codegen/box/contracts/listAppend.kt"); } + @Test @TestMetadata("nestedLambdaInNonInlineCallExactlyOnce.kt") public void testNestedLambdaInNonInlineCallExactlyOnce() throws Exception { runTest("compiler/testData/codegen/box/contracts/nestedLambdaInNonInlineCallExactlyOnce.kt"); } + @Test @TestMetadata("valInWhen.kt") public void testValInWhen() throws Exception { runTest("compiler/testData/codegen/box/contracts/valInWhen.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/controlStructures") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ControlStructures extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ControlStructures { + @Test public void testAllFilesPresentInControlStructures() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("bottles.kt") public void testBottles() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/bottles.kt"); } + @Test @TestMetadata("breakInFinally.kt") public void testBreakInFinally() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakInFinally.kt"); } + @Test @TestMetadata("breakInWhen.kt") public void testBreakInWhen() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakInWhen.kt"); } + @Test @TestMetadata("compareBoxedIntegerToZero.kt") public void testCompareBoxedIntegerToZero() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/compareBoxedIntegerToZero.kt"); } + @Test @TestMetadata("conditionOfEmptyIf.kt") public void testConditionOfEmptyIf() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/conditionOfEmptyIf.kt"); } + @Test @TestMetadata("continueInExpr.kt") public void testContinueInExpr() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/continueInExpr.kt"); } + @Test @TestMetadata("continueInFor.kt") public void testContinueInFor() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/continueInFor.kt"); } + @Test @TestMetadata("continueInForCondition.kt") public void testContinueInForCondition() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/continueInForCondition.kt"); } + @Test @TestMetadata("continueInWhen.kt") public void testContinueInWhen() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/continueInWhen.kt"); } + @Test @TestMetadata("continueInWhile.kt") public void testContinueInWhile() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/continueInWhile.kt"); } + @Test @TestMetadata("continueToLabelInFor.kt") public void testContinueToLabelInFor() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/continueToLabelInFor.kt"); } + @Test @TestMetadata("doWhile.kt") public void testDoWhile() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/doWhile.kt"); } + @Test @TestMetadata("doWhileFib.kt") public void testDoWhileFib() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/doWhileFib.kt"); } + @Test @TestMetadata("doWhileWithContinue.kt") public void testDoWhileWithContinue() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/doWhileWithContinue.kt"); } + @Test @TestMetadata("emptyDoWhile.kt") public void testEmptyDoWhile() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/emptyDoWhile.kt"); } + @Test @TestMetadata("emptyFor.kt") public void testEmptyFor() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/emptyFor.kt"); } + @Test @TestMetadata("emptyWhile.kt") public void testEmptyWhile() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/emptyWhile.kt"); } + @Test @TestMetadata("factorialTest.kt") public void testFactorialTest() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/factorialTest.kt"); } + @Test @TestMetadata("finallyOnEmptyReturn.kt") public void testFinallyOnEmptyReturn() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/finallyOnEmptyReturn.kt"); } + @Test @TestMetadata("forArrayList.kt") public void testForArrayList() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forArrayList.kt"); } + @Test @TestMetadata("forArrayListMultiDecl.kt") public void testForArrayListMultiDecl() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forArrayListMultiDecl.kt"); } + @Test @TestMetadata("forInCharSequence.kt") public void testForInCharSequence() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInCharSequence.kt"); } + @Test @TestMetadata("forInCharSequenceMut.kt") public void testForInCharSequenceMut() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceMut.kt"); } + @Test @TestMetadata("forInSmartCastToArray.kt") public void testForInSmartCastToArray() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInSmartCastToArray.kt"); } + @Test @TestMetadata("forLoopMemberExtensionAll.kt") public void testForLoopMemberExtensionAll() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forLoopMemberExtensionAll.kt"); } + @Test @TestMetadata("forLoopMemberExtensionHasNext.kt") public void testForLoopMemberExtensionHasNext() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forLoopMemberExtensionHasNext.kt"); } + @Test @TestMetadata("forLoopMemberExtensionNext.kt") public void testForLoopMemberExtensionNext() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forLoopMemberExtensionNext.kt"); } + @Test @TestMetadata("forNullableCharInString.kt") public void testForNullableCharInString() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forNullableCharInString.kt"); } + @Test @TestMetadata("forUserType.kt") public void testForUserType() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forUserType.kt"); } + @Test @TestMetadata("ifConst1.kt") public void testIfConst1() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/ifConst1.kt"); } + @Test @TestMetadata("ifConst2.kt") public void testIfConst2() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/ifConst2.kt"); } + @Test @TestMetadata("ifIncompatibleBranches.kt") public void testIfIncompatibleBranches() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/ifIncompatibleBranches.kt"); } + @Test @TestMetadata("inRangeConditionsInWhen.kt") public void testInRangeConditionsInWhen() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/inRangeConditionsInWhen.kt"); } + @Test @TestMetadata("kt12908.kt") public void testKt12908() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt12908.kt"); } + @Test @TestMetadata("kt12908_2.kt") public void testKt12908_2() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt12908_2.kt"); } + @Test @TestMetadata("kt1441.kt") public void testKt1441() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt1441.kt"); } + @Test @TestMetadata("kt14839.kt") public void testKt14839() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt14839.kt"); } + @Test @TestMetadata("kt15726.kt") public void testKt15726() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt15726.kt"); } + @Test @TestMetadata("kt1688.kt") public void testKt1688() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt1688.kt"); } + @Test @TestMetadata("kt17110.kt") public void testKt17110() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt17110.kt"); } + @Test @TestMetadata("kt1742.kt") public void testKt1742() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt1742.kt"); } + @Test @TestMetadata("kt17590.kt") public void testKt17590() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt17590.kt"); } + @Test @TestMetadata("kt17590_long.kt") public void testKt17590_long() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt17590_long.kt"); } + @Test @TestMetadata("kt1899.kt") public void testKt1899() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt1899.kt"); } + @Test @TestMetadata("kt2147.kt") public void testKt2147() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt2147.kt"); } + @Test @TestMetadata("kt2259.kt") public void testKt2259() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt2259.kt"); } + @Test @TestMetadata("kt2291.kt") public void testKt2291() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt2291.kt"); } + @Test @TestMetadata("kt237.kt") public void testKt237() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt237.kt"); } + @Test @TestMetadata("kt2416.kt") public void testKt2416() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt2416.kt"); } + @Test @TestMetadata("kt2577.kt") public void testKt2577() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt2577.kt"); } + @Test @TestMetadata("kt2597.kt") public void testKt2597() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt2597.kt"); } + @Test @TestMetadata("kt299.kt") public void testKt299() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt299.kt"); } + @Test @TestMetadata("kt3087.kt") public void testKt3087() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt3087.kt"); } + @Test @TestMetadata("kt3203_1.kt") public void testKt3203_1() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt3203_1.kt"); } + @Test @TestMetadata("kt3203_2.kt") public void testKt3203_2() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt3203_2.kt"); } + @Test @TestMetadata("kt3273.kt") public void testKt3273() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt3273.kt"); } + @Test @TestMetadata("kt3280.kt") public void testKt3280() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt3280.kt"); } + @Test @TestMetadata("kt416.kt") public void testKt416() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt416.kt"); } + @Test @TestMetadata("kt42455.kt") public void testKt42455() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt42455.kt"); } + @Test @TestMetadata("kt47245.kt") public void testKt47245() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt47245.kt"); } + @Test @TestMetadata("kt513.kt") public void testKt513() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt513.kt"); } + @Test @TestMetadata("kt628.kt") public void testKt628() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt628.kt"); } + @Test @TestMetadata("kt769.kt") public void testKt769() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt769.kt"); } + @Test @TestMetadata("kt772.kt") public void testKt772() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt772.kt"); } + @Test @TestMetadata("kt773.kt") public void testKt773() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt773.kt"); } + @Test @TestMetadata("kt8148.kt") public void testKt8148() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt8148.kt"); } + @Test @TestMetadata("kt8148_break.kt") public void testKt8148_break() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt8148_break.kt"); } + @Test @TestMetadata("kt8148_continue.kt") public void testKt8148_continue() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt8148_continue.kt"); } + @Test @TestMetadata("kt870.kt") public void testKt870() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt870.kt"); } + @Test @TestMetadata("kt9022Return.kt") public void testKt9022Return() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt9022Return.kt"); } + @Test @TestMetadata("kt9022Throw.kt") public void testKt9022Throw() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt9022Throw.kt"); } + @Test @TestMetadata("kt910.kt") public void testKt910() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt910.kt"); } + @Test @TestMetadata("kt958.kt") public void testKt958() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/kt958.kt"); } + @Test @TestMetadata("longRange.kt") public void testLongRange() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/longRange.kt"); } + @Test @TestMetadata("parameterWithNameForFunctionType.kt") public void testParameterWithNameForFunctionType() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/parameterWithNameForFunctionType.kt"); } + @Test @TestMetadata("quicksort.kt") public void testQuicksort() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/quicksort.kt"); } + @Test @TestMetadata("tcbInEliminatedCondition.kt") public void testTcbInEliminatedCondition() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tcbInEliminatedCondition.kt"); } + @Test @TestMetadata("tryCatchExpression.kt") public void testTryCatchExpression() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchExpression.kt"); } + @Test @TestMetadata("tryCatchFinally.kt") public void testTryCatchFinally() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchFinally.kt"); } + @Test @TestMetadata("tryCatchFinallyChain.kt") public void testTryCatchFinallyChain() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchFinallyChain.kt"); } + @Test @TestMetadata("tryFinally.kt") public void testTryFinally() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryFinally.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class BreakContinueInExpressions extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class BreakContinueInExpressions { + @Test public void testAllFilesPresentInBreakContinueInExpressions() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("breakFromOuter.kt") public void testBreakFromOuter() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/breakFromOuter.kt"); } + @Test @TestMetadata("breakInDoWhile.kt") public void testBreakInDoWhile() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/breakInDoWhile.kt"); } + @Test @TestMetadata("breakInExpr.kt") public void testBreakInExpr() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/breakInExpr.kt"); } + @Test @TestMetadata("breakInLoopConditions.kt") public void testBreakInLoopConditions() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/breakInLoopConditions.kt"); } + @Test @TestMetadata("continueInDoWhile.kt") public void testContinueInDoWhile() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/continueInDoWhile.kt"); } + @Test @TestMetadata("continueInExpr.kt") public void testContinueInExpr() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/continueInExpr.kt"); } + @Test @TestMetadata("inlineWithStack.kt") public void testInlineWithStack() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/inlineWithStack.kt"); } + @Test @TestMetadata("innerLoopWithStack.kt") public void testInnerLoopWithStack() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/innerLoopWithStack.kt"); } + @Test @TestMetadata("kt14581.kt") public void testKt14581() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/kt14581.kt"); } + @Test @TestMetadata("kt16713.kt") public void testKt16713() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/kt16713.kt"); } + @Test @TestMetadata("kt16713_2.kt") public void testKt16713_2() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/kt16713_2.kt"); } + @Test @TestMetadata("kt17384.kt") public void testKt17384() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/kt17384.kt"); } + @Test @TestMetadata("kt45704_elvisInInlineFun.kt") public void testKt45704_elvisInInlineFun() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/kt45704_elvisInInlineFun.kt"); } + @Test @TestMetadata("kt9022And.kt") public void testKt9022And() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/kt9022And.kt"); } + @Test @TestMetadata("kt9022Or.kt") public void testKt9022Or() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/kt9022Or.kt"); } + @Test @TestMetadata("pathologicalDoWhile.kt") public void testPathologicalDoWhile() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/pathologicalDoWhile.kt"); } + @Test @TestMetadata("popSizes.kt") public void testPopSizes() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/popSizes.kt"); } + @Test @TestMetadata("tryFinally1.kt") public void testTryFinally1() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/tryFinally1.kt"); } + @Test @TestMetadata("tryFinally2.kt") public void testTryFinally2() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/tryFinally2.kt"); } + @Test @TestMetadata("whileTrueBreak.kt") public void testWhileTrueBreak() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/whileTrueBreak.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/inlinedBreakContinue") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class InlinedBreakContinue extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class InlinedBreakContinue { + @Test public void testAllFilesPresentInInlinedBreakContinue() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/inlinedBreakContinue"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("initializerBlock.kt") public void testInitializerBlock() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/inlinedBreakContinue/initializerBlock.kt"); } + @Test @TestMetadata("inlineFunctionWithMultipleParameters.kt") public void testInlineFunctionWithMultipleParameters() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/inlinedBreakContinue/inlineFunctionWithMultipleParameters.kt"); } + @Test @TestMetadata("lambdaPassedToInlineFunction.kt") public void testLambdaPassedToInlineFunction() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/inlinedBreakContinue/lambdaPassedToInlineFunction.kt"); } + @Test @TestMetadata("loopWithinInlineFunction.kt") public void testLoopWithinInlineFunction() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/inlinedBreakContinue/loopWithinInlineFunction.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/inlinedBreakContinue/simple.kt"); } + @Test @TestMetadata("stdlibFunctions.kt") public void testStdlibFunctions() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/inlinedBreakContinue/stdlibFunctions.kt"); } + @Test @TestMetadata("withReturnValue.kt") public void testWithReturnValue() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/inlinedBreakContinue/withReturnValue.kt"); @@ -5482,627 +6209,702 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/controlStructures/forInArray") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ForInArray extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ForInArray { + @Test public void testAllFilesPresentInForInArray() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArray"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("forInArraySpecializedToUntil.kt") public void testForInArraySpecializedToUntil() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArray/forInArraySpecializedToUntil.kt"); } + @Test @TestMetadata("forInArrayWithArrayPropertyUpdatedInLoopBody.kt") public void testForInArrayWithArrayPropertyUpdatedInLoopBody() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArray/forInArrayWithArrayPropertyUpdatedInLoopBody.kt"); } + @Test @TestMetadata("forInArrayWithArrayVarUpdatedInLoopBody13.kt") public void testForInArrayWithArrayVarUpdatedInLoopBody13() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArray/forInArrayWithArrayVarUpdatedInLoopBody13.kt"); } + @Test @TestMetadata("forInDelegatedPropertyUpdatedInLoopBody.kt") public void testForInDelegatedPropertyUpdatedInLoopBody() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArray/forInDelegatedPropertyUpdatedInLoopBody.kt"); } + @Test @TestMetadata("forInDoubleArrayWithUpcast.kt") public void testForInDoubleArrayWithUpcast() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArray/forInDoubleArrayWithUpcast.kt"); } + @Test @TestMetadata("forInFieldUpdatedInLoopBody.kt") public void testForInFieldUpdatedInLoopBody() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArray/forInFieldUpdatedInLoopBody.kt"); } + @Test @TestMetadata("forInInlineClassArrayWithUpcast.kt") public void testForInInlineClassArrayWithUpcast() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArray/forInInlineClassArrayWithUpcast.kt"); } + @Test @TestMetadata("forIntArray.kt") public void testForIntArray() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArray/forIntArray.kt"); } + @Test @TestMetadata("forNullableIntArray.kt") public void testForNullableIntArray() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArray/forNullableIntArray.kt"); } + @Test @TestMetadata("forPrimitiveIntArray.kt") public void testForPrimitiveIntArray() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArray/forPrimitiveIntArray.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ForInArrayWithIndex extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ForInArrayWithIndex { + @Test public void testAllFilesPresentInForInArrayWithIndex() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("forInArrayOfObjectArrayWithIndex.kt") public void testForInArrayOfObjectArrayWithIndex() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInArrayOfObjectArrayWithIndex.kt"); } + @Test @TestMetadata("forInArrayOfPrimArrayWithIndex.kt") public void testForInArrayOfPrimArrayWithIndex() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInArrayOfPrimArrayWithIndex.kt"); } + @Test @TestMetadata("forInArrayWithIndexBreakAndContinue.kt") public void testForInArrayWithIndexBreakAndContinue() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInArrayWithIndexBreakAndContinue.kt"); } + @Test @TestMetadata("forInArrayWithIndexContinuesAsUnmodified.kt") public void testForInArrayWithIndexContinuesAsUnmodified() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInArrayWithIndexContinuesAsUnmodified.kt"); } + @Test @TestMetadata("forInArrayWithIndexNoElementVar.kt") public void testForInArrayWithIndexNoElementVar() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInArrayWithIndexNoElementVar.kt"); } + @Test @TestMetadata("forInArrayWithIndexNoIndexOrElementVar.kt") public void testForInArrayWithIndexNoIndexOrElementVar() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInArrayWithIndexNoIndexOrElementVar.kt"); } + @Test @TestMetadata("forInArrayWithIndexNoIndexVar.kt") public void testForInArrayWithIndexNoIndexVar() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInArrayWithIndexNoIndexVar.kt"); } + @Test @TestMetadata("forInArrayWithIndexNotDestructured.kt") public void testForInArrayWithIndexNotDestructured() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInArrayWithIndexNotDestructured.kt"); } + @Test @TestMetadata("forInArrayWithIndexWithExplicitlyTypedIndexVariable.kt") public void testForInArrayWithIndexWithExplicitlyTypedIndexVariable() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInArrayWithIndexWithExplicitlyTypedIndexVariable.kt"); } + @Test @TestMetadata("forInByteArrayWithIndex.kt") public void testForInByteArrayWithIndex() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInByteArrayWithIndex.kt"); } + @Test @TestMetadata("forInByteArrayWithIndexWithSmartCast.kt") public void testForInByteArrayWithIndexWithSmartCast() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInByteArrayWithIndexWithSmartCast.kt"); } + @Test @TestMetadata("forInEmptyArrayWithIndex.kt") public void testForInEmptyArrayWithIndex() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInEmptyArrayWithIndex.kt"); } + @Test @TestMetadata("forInGenericArrayOfIntsWithIndex.kt") public void testForInGenericArrayOfIntsWithIndex() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInGenericArrayOfIntsWithIndex.kt"); } + @Test @TestMetadata("forInGenericArrayOfIntsWithIndexWithSmartCast.kt") public void testForInGenericArrayOfIntsWithIndexWithSmartCast() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInGenericArrayOfIntsWithIndexWithSmartCast.kt"); } + @Test @TestMetadata("forInGenericArrayWithIndex.kt") public void testForInGenericArrayWithIndex() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInGenericArrayWithIndex.kt"); } + @Test @TestMetadata("forInIntArrayWithIndex.kt") public void testForInIntArrayWithIndex() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInIntArrayWithIndex.kt"); } + @Test @TestMetadata("forInIntArrayWithIndexWithSmartCast.kt") public void testForInIntArrayWithIndexWithSmartCast() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInIntArrayWithIndexWithSmartCast.kt"); } + @Test @TestMetadata("forInObjectArrayWithIndex.kt") public void testForInObjectArrayWithIndex() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInObjectArrayWithIndex.kt"); } + @Test @TestMetadata("forInShortArrayWithIndex.kt") public void testForInShortArrayWithIndex() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInShortArrayWithIndex.kt"); } + @Test @TestMetadata("forInShortArrayWithIndexWithSmartCast.kt") public void testForInShortArrayWithIndexWithSmartCast() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInShortArrayWithIndexWithSmartCast.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ForInCharSequenceWithIndex extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ForInCharSequenceWithIndex { + @Test public void testAllFilesPresentInForInCharSequenceWithIndex() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("forInCharSeqWithIndexStops.kt") public void testForInCharSeqWithIndexStops() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInCharSeqWithIndexStops.kt"); } + @Test @TestMetadata("forInCharSequenceTypeParameterWithIndex.kt") public void testForInCharSequenceTypeParameterWithIndex() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInCharSequenceTypeParameterWithIndex.kt"); } + @Test @TestMetadata("forInCharSequenceWithIndex.kt") public void testForInCharSequenceWithIndex() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInCharSequenceWithIndex.kt"); } + @Test @TestMetadata("forInCharSequenceWithIndexBreakAndContinue.kt") public void testForInCharSequenceWithIndexBreakAndContinue() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInCharSequenceWithIndexBreakAndContinue.kt"); } + @Test @TestMetadata("forInCharSequenceWithIndexCheckSideEffects.kt") public void testForInCharSequenceWithIndexCheckSideEffects() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInCharSequenceWithIndexCheckSideEffects.kt"); } + @Test @TestMetadata("forInCharSequenceWithIndexNoElementVarCheckSideEffects.kt") public void testForInCharSequenceWithIndexNoElementVarCheckSideEffects() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInCharSequenceWithIndexNoElementVarCheckSideEffects.kt"); } + @Test @TestMetadata("forInCharSequenceWithIndexNoIndexVarCheckSideEffects.kt") public void testForInCharSequenceWithIndexNoIndexVarCheckSideEffects() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInCharSequenceWithIndexNoIndexVarCheckSideEffects.kt"); } + @Test @TestMetadata("forInEmptyStringWithIndex.kt") public void testForInEmptyStringWithIndex() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInEmptyStringWithIndex.kt"); } + @Test @TestMetadata("forInStringWithIndex.kt") public void testForInStringWithIndex() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInStringWithIndex.kt"); } + @Test @TestMetadata("forInStringWithIndexNoElementVar.kt") public void testForInStringWithIndexNoElementVar() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInStringWithIndexNoElementVar.kt"); } + @Test @TestMetadata("forInStringWithIndexNoIndexOrElementVar.kt") public void testForInStringWithIndexNoIndexOrElementVar() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInStringWithIndexNoIndexOrElementVar.kt"); } + @Test @TestMetadata("forInStringWithIndexNoIndexVar.kt") public void testForInStringWithIndexNoIndexVar() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInStringWithIndexNoIndexVar.kt"); } + @Test @TestMetadata("forInStringWithIndexNotDestructured.kt") public void testForInStringWithIndexNotDestructured() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInStringWithIndexNotDestructured.kt"); } + @Test @TestMetadata("forInStringWithIndexWithExplicitlyTypedIndexVariable.kt") public void testForInStringWithIndexWithExplicitlyTypedIndexVariable() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInStringWithIndexWithExplicitlyTypedIndexVariable.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ForInIterableWithIndex extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ForInIterableWithIndex { + @Test public void testAllFilesPresentInForInIterableWithIndex() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("forInEmptyListWithIndex.kt") public void testForInEmptyListWithIndex() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex/forInEmptyListWithIndex.kt"); } + @Test @TestMetadata("forInIterableTypeParameterWithIndex.kt") public void testForInIterableTypeParameterWithIndex() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex/forInIterableTypeParameterWithIndex.kt"); } + @Test @TestMetadata("forInIterableWithIndexCheckSideEffects.kt") public void testForInIterableWithIndexCheckSideEffects() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex/forInIterableWithIndexCheckSideEffects.kt"); } + @Test @TestMetadata("forInIterableWithIndexNoElementVarCheckSideEffects.kt") public void testForInIterableWithIndexNoElementVarCheckSideEffects() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex/forInIterableWithIndexNoElementVarCheckSideEffects.kt"); } + @Test @TestMetadata("forInIterableWithIndexNoIndexVarCheckSideEffects.kt") public void testForInIterableWithIndexNoIndexVarCheckSideEffects() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex/forInIterableWithIndexNoIndexVarCheckSideEffects.kt"); } + @Test @TestMetadata("forInListWithIndex.kt") public void testForInListWithIndex() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex/forInListWithIndex.kt"); } + @Test @TestMetadata("forInListWithIndexBreak.kt") public void testForInListWithIndexBreak() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex/forInListWithIndexBreak.kt"); } + @Test @TestMetadata("forInListWithIndexBreakAndContinue.kt") public void testForInListWithIndexBreakAndContinue() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex/forInListWithIndexBreakAndContinue.kt"); } + @Test @TestMetadata("forInListWithIndexContinue.kt") public void testForInListWithIndexContinue() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex/forInListWithIndexContinue.kt"); } + @Test @TestMetadata("forInListWithIndexNoElementVar.kt") public void testForInListWithIndexNoElementVar() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex/forInListWithIndexNoElementVar.kt"); } + @Test @TestMetadata("forInListWithIndexNoIndexVar.kt") public void testForInListWithIndexNoIndexVar() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex/forInListWithIndexNoIndexVar.kt"); } + @Test @TestMetadata("forInListWithIndexWithExplicitlyTypedIndexVariable.kt") public void testForInListWithIndexWithExplicitlyTypedIndexVariable() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex/forInListWithIndexWithExplicitlyTypedIndexVariable.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/controlStructures/forInIterator") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ForInIterator extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ForInIterator { + @Test public void testAllFilesPresentInForInIterator() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInIterator"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ForInSequenceWithIndex extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ForInSequenceWithIndex { + @Test public void testAllFilesPresentInForInSequenceWithIndex() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("forInEmptySequenceWithIndex.kt") public void testForInEmptySequenceWithIndex() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex/forInEmptySequenceWithIndex.kt"); } + @Test @TestMetadata("forInSequenceTypeParameterWithIndex.kt") public void testForInSequenceTypeParameterWithIndex() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex/forInSequenceTypeParameterWithIndex.kt"); } + @Test @TestMetadata("forInSequenceWithIndex.kt") public void testForInSequenceWithIndex() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex/forInSequenceWithIndex.kt"); } + @Test @TestMetadata("forInSequenceWithIndexBreakAndContinue.kt") public void testForInSequenceWithIndexBreakAndContinue() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex/forInSequenceWithIndexBreakAndContinue.kt"); } + @Test @TestMetadata("forInSequenceWithIndexCheckSideEffects.kt") public void testForInSequenceWithIndexCheckSideEffects() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex/forInSequenceWithIndexCheckSideEffects.kt"); } + @Test @TestMetadata("forInSequenceWithIndexNoElementVar.kt") public void testForInSequenceWithIndexNoElementVar() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex/forInSequenceWithIndexNoElementVar.kt"); } + @Test @TestMetadata("forInSequenceWithIndexNoElementVarCheckSideEffects.kt") public void testForInSequenceWithIndexNoElementVarCheckSideEffects() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex/forInSequenceWithIndexNoElementVarCheckSideEffects.kt"); } + @Test @TestMetadata("forInSequenceWithIndexNoIndexVar.kt") public void testForInSequenceWithIndexNoIndexVar() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex/forInSequenceWithIndexNoIndexVar.kt"); } + @Test @TestMetadata("forInSequenceWithIndexNoIndexVarCheckSideEffects.kt") public void testForInSequenceWithIndexNoIndexVarCheckSideEffects() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex/forInSequenceWithIndexNoIndexVarCheckSideEffects.kt"); } + @Test @TestMetadata("forInSequenceWithIndexWithExplicitlyTypedIndexVariable.kt") public void testForInSequenceWithIndexWithExplicitlyTypedIndexVariable() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex/forInSequenceWithIndexWithExplicitlyTypedIndexVariable.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/controlStructures/returnsNothing") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ReturnsNothing extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ReturnsNothing { + @Test public void testAllFilesPresentInReturnsNothing() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/returnsNothing"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("ifElse.kt") public void testIfElse() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/returnsNothing/ifElse.kt"); } + @Test @TestMetadata("inlineMethod.kt") public void testInlineMethod() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/returnsNothing/inlineMethod.kt"); } + @Test @TestMetadata("propertyGetter.kt") public void testPropertyGetter() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/returnsNothing/propertyGetter.kt"); } + @Test @TestMetadata("tryCatch.kt") public void testTryCatch() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/returnsNothing/tryCatch.kt"); } + @Test @TestMetadata("when.kt") public void testWhen() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/returnsNothing/when.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/controlStructures/slowDsl") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SlowDsl extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class SlowDsl { + @Test public void testAllFilesPresentInSlowDsl() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/slowDsl"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TryCatchInExpressions extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class TryCatchInExpressions { + @Test public void testAllFilesPresentInTryCatchInExpressions() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("catch.kt") public void testCatch() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/catch.kt"); } + @Test @TestMetadata("complexChain.kt") public void testComplexChain() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/complexChain.kt"); } + @Test @TestMetadata("deadTryCatch.kt") public void testDeadTryCatch() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/deadTryCatch.kt"); } + @Test @TestMetadata("differentTypes.kt") public void testDifferentTypes() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/differentTypes.kt"); } + @Test @TestMetadata("expectException.kt") public void testExpectException() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/expectException.kt"); } + @Test @TestMetadata("finally.kt") public void testFinally() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/finally.kt"); } + @Test @TestMetadata("inlineTryCatch.kt") public void testInlineTryCatch() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/inlineTryCatch.kt"); } + @Test @TestMetadata("inlineTryExpr.kt") public void testInlineTryExpr() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/inlineTryExpr.kt"); } + @Test @TestMetadata("inlineTryFinally.kt") public void testInlineTryFinally() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/inlineTryFinally.kt"); } + @Test @TestMetadata("kt17572.kt") public void testKt17572() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/kt17572.kt"); } + @Test @TestMetadata("kt17572_2.kt") public void testKt17572_2() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/kt17572_2.kt"); } + @Test @TestMetadata("kt17572_2_ext.kt") public void testKt17572_2_ext() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/kt17572_2_ext.kt"); } + @Test @TestMetadata("kt17572_ext.kt") public void testKt17572_ext() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/kt17572_ext.kt"); } + @Test @TestMetadata("kt17572_nested.kt") public void testKt17572_nested() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/kt17572_nested.kt"); } + @Test @TestMetadata("kt17573.kt") public void testKt17573() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/kt17573.kt"); } + @Test @TestMetadata("kt17573_nested.kt") public void testKt17573_nested() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/kt17573_nested.kt"); } + @Test @TestMetadata("kt8608.kt") public void testKt8608() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/kt8608.kt"); } + @Test @TestMetadata("kt9644try.kt") public void testKt9644try() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/kt9644try.kt"); } + @Test @TestMetadata("multipleCatchBlocks.kt") public void testMultipleCatchBlocks() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/multipleCatchBlocks.kt"); } + @Test @TestMetadata("nonLocalReturnInTryFinally.kt") public void testNonLocalReturnInTryFinally() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/nonLocalReturnInTryFinally.kt"); } + @Test @TestMetadata("splitTry.kt") public void testSplitTry() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/splitTry.kt"); } + @Test @TestMetadata("splitTryCorner1.kt") public void testSplitTryCorner1() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/splitTryCorner1.kt"); } + @Test @TestMetadata("splitTryCorner2.kt") public void testSplitTryCorner2() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/splitTryCorner2.kt"); } + @Test @TestMetadata("try.kt") public void testTry() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/try.kt"); } + @Test @TestMetadata("tryAfterTry.kt") public void testTryAfterTry() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryAfterTry.kt"); } + @Test @TestMetadata("tryAndBreak.kt") public void testTryAndBreak() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryAndBreak.kt"); } + @Test @TestMetadata("tryAndContinue.kt") public void testTryAndContinue() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryAndContinue.kt"); } + @Test @TestMetadata("tryCatchAfterWhileTrue.kt") public void testTryCatchAfterWhileTrue() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryCatchAfterWhileTrue.kt"); } + @Test @TestMetadata("tryInsideCatch.kt") public void testTryInsideCatch() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryInsideCatch.kt"); } + @Test @TestMetadata("tryInsideTry.kt") public void testTryInsideTry() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryInsideTry.kt"); } + @Test @TestMetadata("unmatchedInlineMarkers.kt") public void testUnmatchedInlineMarkers() throws Exception { runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/unmatchedInlineMarkers.kt"); @@ -6110,1043 +6912,1202 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Coroutines extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Coroutines { + @Test @TestMetadata("32defaultParametersInSuspend.kt") public void test32defaultParametersInSuspend() throws Exception { runTest("compiler/testData/codegen/box/coroutines/32defaultParametersInSuspend.kt"); } + @Test @TestMetadata("accessorForSuspend.kt") public void testAccessorForSuspend() throws Exception { runTest("compiler/testData/codegen/box/coroutines/accessorForSuspend.kt"); } + @Test public void testAllFilesPresentInCoroutines() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("asyncIteratorNullMerge_1_3.kt") public void testAsyncIteratorNullMerge_1_3() throws Exception { runTest("compiler/testData/codegen/box/coroutines/asyncIteratorNullMerge_1_3.kt"); } + @Test @TestMetadata("asyncIteratorToList_1_3.kt") public void testAsyncIteratorToList_1_3() throws Exception { runTest("compiler/testData/codegen/box/coroutines/asyncIteratorToList_1_3.kt"); } + @Test @TestMetadata("asyncIterator_1_3.kt") public void testAsyncIterator_1_3() throws Exception { runTest("compiler/testData/codegen/box/coroutines/asyncIterator_1_3.kt"); } + @Test @TestMetadata("await.kt") public void testAwait() throws Exception { runTest("compiler/testData/codegen/box/coroutines/await.kt"); } + @Test @TestMetadata("beginWithException.kt") public void testBeginWithException() throws Exception { runTest("compiler/testData/codegen/box/coroutines/beginWithException.kt"); } + @Test @TestMetadata("beginWithExceptionNoHandleException.kt") public void testBeginWithExceptionNoHandleException() throws Exception { runTest("compiler/testData/codegen/box/coroutines/beginWithExceptionNoHandleException.kt"); } + @Test @TestMetadata("builderInferenceAndGenericArrayAcessCall.kt") public void testBuilderInferenceAndGenericArrayAcessCall() throws Exception { runTest("compiler/testData/codegen/box/coroutines/builderInferenceAndGenericArrayAcessCall.kt"); } + @Test @TestMetadata("captureInfixFun.kt") public void testCaptureInfixFun() throws Exception { runTest("compiler/testData/codegen/box/coroutines/captureInfixFun.kt"); } + @Test @TestMetadata("captureMutableLocalVariableInsideCoroutineBlock.kt") public void testCaptureMutableLocalVariableInsideCoroutineBlock() throws Exception { runTest("compiler/testData/codegen/box/coroutines/captureMutableLocalVariableInsideCoroutineBlock.kt"); } + @Test @TestMetadata("captureUnaryOperator.kt") public void testCaptureUnaryOperator() throws Exception { runTest("compiler/testData/codegen/box/coroutines/captureUnaryOperator.kt"); } + @Test @TestMetadata("capturedVarInSuspendLambda.kt") public void testCapturedVarInSuspendLambda() throws Exception { runTest("compiler/testData/codegen/box/coroutines/capturedVarInSuspendLambda.kt"); } + @Test @TestMetadata("castWithSuspend.kt") public void testCastWithSuspend() throws Exception { runTest("compiler/testData/codegen/box/coroutines/castWithSuspend.kt"); } + @Test @TestMetadata("catchWithInlineInsideSuspend.kt") public void testCatchWithInlineInsideSuspend() throws Exception { runTest("compiler/testData/codegen/box/coroutines/catchWithInlineInsideSuspend.kt"); } + @Test @TestMetadata("coercionToUnit.kt") public void testCoercionToUnit() throws Exception { runTest("compiler/testData/codegen/box/coroutines/coercionToUnit.kt"); } + @Test @TestMetadata("controllerAccessFromInnerLambda.kt") public void testControllerAccessFromInnerLambda() throws Exception { runTest("compiler/testData/codegen/box/coroutines/controllerAccessFromInnerLambda.kt"); } + @Test @TestMetadata("coroutineContextInInlinedLambda.kt") public void testCoroutineContextInInlinedLambda() throws Exception { runTest("compiler/testData/codegen/box/coroutines/coroutineContextInInlinedLambda.kt"); } + @Test @TestMetadata("createCoroutineSafe.kt") public void testCreateCoroutineSafe() throws Exception { runTest("compiler/testData/codegen/box/coroutines/createCoroutineSafe.kt"); } + @Test @TestMetadata("createCoroutinesOnManualInstances.kt") public void testCreateCoroutinesOnManualInstances() throws Exception { runTest("compiler/testData/codegen/box/coroutines/createCoroutinesOnManualInstances.kt"); } + @Test @TestMetadata("crossInlineWithCapturedOuterReceiver.kt") public void testCrossInlineWithCapturedOuterReceiver() throws Exception { runTest("compiler/testData/codegen/box/coroutines/crossInlineWithCapturedOuterReceiver.kt"); } + @Test @TestMetadata("defaultParameterLambdaInSuspend.kt") public void testDefaultParameterLambdaInSuspend() throws Exception { runTest("compiler/testData/codegen/box/coroutines/defaultParameterLambdaInSuspend.kt"); } + @Test @TestMetadata("defaultParametersInSuspend.kt") public void testDefaultParametersInSuspend() throws Exception { runTest("compiler/testData/codegen/box/coroutines/defaultParametersInSuspend.kt"); } + @Test @TestMetadata("delegatedSuspendMember.kt") public void testDelegatedSuspendMember() throws Exception { runTest("compiler/testData/codegen/box/coroutines/delegatedSuspendMember.kt"); } + @Test @TestMetadata("dispatchResume.kt") public void testDispatchResume() throws Exception { runTest("compiler/testData/codegen/box/coroutines/dispatchResume.kt"); } + @Test @TestMetadata("doubleColonExpressionsGenerationInBuilderInference.kt") public void testDoubleColonExpressionsGenerationInBuilderInference() throws Exception { runTest("compiler/testData/codegen/box/coroutines/doubleColonExpressionsGenerationInBuilderInference.kt"); } + @Test @TestMetadata("emptyClosure.kt") public void testEmptyClosure() throws Exception { runTest("compiler/testData/codegen/box/coroutines/emptyClosure.kt"); } + @Test @TestMetadata("emptyCommonConstraintSystemForCoroutineInferenceCall.kt") public void testEmptyCommonConstraintSystemForCoroutineInferenceCall() throws Exception { runTest("compiler/testData/codegen/box/coroutines/emptyCommonConstraintSystemForCoroutineInferenceCall.kt"); } + @Test @TestMetadata("epam.kt") public void testEpam() throws Exception { runTest("compiler/testData/codegen/box/coroutines/epam.kt"); } + @Test @TestMetadata("falseUnitCoercion.kt") public void testFalseUnitCoercion() throws Exception { runTest("compiler/testData/codegen/box/coroutines/falseUnitCoercion.kt"); } + @Test @TestMetadata("generate.kt") public void testGenerate() throws Exception { runTest("compiler/testData/codegen/box/coroutines/generate.kt"); } + @Test @TestMetadata("handleException.kt") public void testHandleException() throws Exception { runTest("compiler/testData/codegen/box/coroutines/handleException.kt"); } + @Test @TestMetadata("handleResultCallEmptyBody.kt") public void testHandleResultCallEmptyBody() throws Exception { runTest("compiler/testData/codegen/box/coroutines/handleResultCallEmptyBody.kt"); } + @Test @TestMetadata("handleResultNonUnitExpression.kt") public void testHandleResultNonUnitExpression() throws Exception { runTest("compiler/testData/codegen/box/coroutines/handleResultNonUnitExpression.kt"); } + @Test @TestMetadata("handleResultSuspended.kt") public void testHandleResultSuspended() throws Exception { runTest("compiler/testData/codegen/box/coroutines/handleResultSuspended.kt"); } + @Test @TestMetadata("indirectInlineUsedAsNonInline.kt") public void testIndirectInlineUsedAsNonInline() throws Exception { runTest("compiler/testData/codegen/box/coroutines/indirectInlineUsedAsNonInline.kt"); } + @Test @TestMetadata("infiniteLoopInNextMeaningful.kt") public void testInfiniteLoopInNextMeaningful() throws Exception { runTest("compiler/testData/codegen/box/coroutines/infiniteLoopInNextMeaningful.kt"); } + @Test @TestMetadata("inlineCallWithReturns.kt") public void testInlineCallWithReturns() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineCallWithReturns.kt"); } + @Test @TestMetadata("inlineFunInGenericClass.kt") public void testInlineFunInGenericClass() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineFunInGenericClass.kt"); } + @Test @TestMetadata("inlineGenericFunCalledFromSubclass.kt") public void testInlineGenericFunCalledFromSubclass() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineGenericFunCalledFromSubclass.kt"); } + @Test @TestMetadata("inlineSuspendFunction.kt") public void testInlineSuspendFunction() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineSuspendFunction.kt"); } + @Test @TestMetadata("inlineSuspendLambdaNonLocalReturn.kt") public void testInlineSuspendLambdaNonLocalReturn() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineSuspendLambdaNonLocalReturn.kt"); } + @Test @TestMetadata("inlineSuspendTypealias.kt") public void testInlineSuspendTypealias() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineSuspendTypealias.kt"); } + @Test @TestMetadata("inlinedTryCatchFinally.kt") public void testInlinedTryCatchFinally() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlinedTryCatchFinally.kt"); } + @Test @TestMetadata("innerSuspensionCalls.kt") public void testInnerSuspensionCalls() throws Exception { runTest("compiler/testData/codegen/box/coroutines/innerSuspensionCalls.kt"); } + @Test @TestMetadata("instanceOfContinuation.kt") public void testInstanceOfContinuation() throws Exception { runTest("compiler/testData/codegen/box/coroutines/instanceOfContinuation.kt"); } + @Test @TestMetadata("iterateOverArray.kt") public void testIterateOverArray() throws Exception { runTest("compiler/testData/codegen/box/coroutines/iterateOverArray.kt"); } + @Test @TestMetadata("kt12958.kt") public void testKt12958() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt12958.kt"); } + @Test @TestMetadata("kt15016.kt") public void testKt15016() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt15016.kt"); } + @Test @TestMetadata("kt15017.kt") public void testKt15017() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt15017.kt"); } + @Test @TestMetadata("kt15930.kt") public void testKt15930() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt15930.kt"); } + @Test @TestMetadata("kt21080.kt") public void testKt21080() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt21080.kt"); } + @Test @TestMetadata("kt21605.kt") public void testKt21605() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt21605.kt"); } + @Test @TestMetadata("kt24135.kt") public void testKt24135() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt24135.kt"); } + @Test @TestMetadata("kt25912.kt") public void testKt25912() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt25912.kt"); } + @Test @TestMetadata("kt28844.kt") public void testKt28844() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt28844.kt"); } + @Test @TestMetadata("kt30858.kt") public void testKt30858() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt30858.kt"); } + @Test @TestMetadata("kt31784.kt") public void testKt31784() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt31784.kt"); } + @Test @TestMetadata("kt35967.kt") public void testKt35967() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt35967.kt"); } + @Test @TestMetadata("kt42028.kt") public void testKt42028() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt42028.kt"); } + @Test @TestMetadata("kt42554.kt") public void testKt42554() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt42554.kt"); } + @Test @TestMetadata("kt44221.kt") public void testKt44221() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt44221.kt"); } + @Test @TestMetadata("kt44710.kt") public void testKt44710() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt44710.kt"); } + @Test @TestMetadata("kt44781.kt") public void testKt44781() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt44781.kt"); } + @Test @TestMetadata("kt45377.kt") public void testKt45377() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt45377.kt"); } + @Test @TestMetadata("kt46813.kt") public void testKt46813() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt46813.kt"); } + @Test @TestMetadata("kt49168.kt") public void testKt49168() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt49168.kt"); } + @Test @TestMetadata("kt49317.kt") public void testKt49317() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt49317.kt"); } + @Test @TestMetadata("kt51530.kt") public void testKt51530() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt51530.kt"); } + @Test @TestMetadata("kt51718.kt") public void testKt51718() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt51718.kt"); } + @Test @TestMetadata("kt52311_nullOnLeft.kt") public void testKt52311_nullOnLeft() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt52311_nullOnLeft.kt"); } + @Test @TestMetadata("kt52311_nullOnRight.kt") public void testKt52311_nullOnRight() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt52311_nullOnRight.kt"); } + @Test @TestMetadata("kt52561.kt") public void testKt52561() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt52561.kt"); } + @Test @TestMetadata("kt55494.kt") public void testKt55494() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt55494.kt"); } + @Test @TestMetadata("kt56407.kt") public void testKt56407() throws Exception { runTest("compiler/testData/codegen/box/coroutines/kt56407.kt"); } + @Test @TestMetadata("lastExpressionIsLoop.kt") public void testLastExpressionIsLoop() throws Exception { runTest("compiler/testData/codegen/box/coroutines/lastExpressionIsLoop.kt"); } + @Test @TestMetadata("lastStatementInc.kt") public void testLastStatementInc() throws Exception { runTest("compiler/testData/codegen/box/coroutines/lastStatementInc.kt"); } + @Test @TestMetadata("lastStementAssignment.kt") public void testLastStementAssignment() throws Exception { runTest("compiler/testData/codegen/box/coroutines/lastStementAssignment.kt"); } + @Test @TestMetadata("lastUnitExpression.kt") public void testLastUnitExpression() throws Exception { runTest("compiler/testData/codegen/box/coroutines/lastUnitExpression.kt"); } + @Test @TestMetadata("localCallableRef.kt") public void testLocalCallableRef() throws Exception { runTest("compiler/testData/codegen/box/coroutines/localCallableRef.kt"); } + @Test @TestMetadata("localDelegate.kt") public void testLocalDelegate() throws Exception { runTest("compiler/testData/codegen/box/coroutines/localDelegate.kt"); } + @Test @TestMetadata("longRangeInSuspendCall.kt") public void testLongRangeInSuspendCall() throws Exception { runTest("compiler/testData/codegen/box/coroutines/longRangeInSuspendCall.kt"); } + @Test @TestMetadata("longRangeInSuspendFun.kt") public void testLongRangeInSuspendFun() throws Exception { runTest("compiler/testData/codegen/box/coroutines/longRangeInSuspendFun.kt"); } + @Test @TestMetadata("mergeNullAndString.kt") public void testMergeNullAndString() throws Exception { runTest("compiler/testData/codegen/box/coroutines/mergeNullAndString.kt"); } + @Test @TestMetadata("multipleInvokeCalls.kt") public void testMultipleInvokeCalls() throws Exception { runTest("compiler/testData/codegen/box/coroutines/multipleInvokeCalls.kt"); } + @Test @TestMetadata("multipleInvokeCallsInsideInlineLambda1.kt") public void testMultipleInvokeCallsInsideInlineLambda1() throws Exception { runTest("compiler/testData/codegen/box/coroutines/multipleInvokeCallsInsideInlineLambda1.kt"); } + @Test @TestMetadata("multipleInvokeCallsInsideInlineLambda2.kt") public void testMultipleInvokeCallsInsideInlineLambda2() throws Exception { runTest("compiler/testData/codegen/box/coroutines/multipleInvokeCallsInsideInlineLambda2.kt"); } + @Test @TestMetadata("multipleInvokeCallsInsideInlineLambda3.kt") public void testMultipleInvokeCallsInsideInlineLambda3() throws Exception { runTest("compiler/testData/codegen/box/coroutines/multipleInvokeCallsInsideInlineLambda3.kt"); } + @Test @TestMetadata("nestedTryCatch.kt") public void testNestedTryCatch() throws Exception { runTest("compiler/testData/codegen/box/coroutines/nestedTryCatch.kt"); } + @Test @TestMetadata("noSuspensionPoints.kt") public void testNoSuspensionPoints() throws Exception { runTest("compiler/testData/codegen/box/coroutines/noSuspensionPoints.kt"); } + @Test @TestMetadata("nonLocalReturn.kt") public void testNonLocalReturn() throws Exception { runTest("compiler/testData/codegen/box/coroutines/nonLocalReturn.kt"); } + @Test @TestMetadata("nonLocalReturnFromInlineLambda.kt") public void testNonLocalReturnFromInlineLambda() throws Exception { runTest("compiler/testData/codegen/box/coroutines/nonLocalReturnFromInlineLambda.kt"); } + @Test @TestMetadata("nonLocalReturnFromInlineLambdaDeep.kt") public void testNonLocalReturnFromInlineLambdaDeep() throws Exception { runTest("compiler/testData/codegen/box/coroutines/nonLocalReturnFromInlineLambdaDeep.kt"); } + @Test @TestMetadata("nullableSuspendFunctionType.kt") public void testNullableSuspendFunctionType() throws Exception { runTest("compiler/testData/codegen/box/coroutines/nullableSuspendFunctionType.kt"); } + @Test @TestMetadata("overrideDefaultArgument.kt") public void testOverrideDefaultArgument() throws Exception { runTest("compiler/testData/codegen/box/coroutines/overrideDefaultArgument.kt"); } + @Test @TestMetadata("recursiveSuspend.kt") public void testRecursiveSuspend() throws Exception { runTest("compiler/testData/codegen/box/coroutines/recursiveSuspend.kt"); } + @Test @TestMetadata("returnByLabel.kt") public void testReturnByLabel() throws Exception { runTest("compiler/testData/codegen/box/coroutines/returnByLabel.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/coroutines/simple.kt"); } + @Test @TestMetadata("simpleException.kt") public void testSimpleException() throws Exception { runTest("compiler/testData/codegen/box/coroutines/simpleException.kt"); } + @Test @TestMetadata("simpleSuspendCallableReference.kt") public void testSimpleSuspendCallableReference() throws Exception { runTest("compiler/testData/codegen/box/coroutines/simpleSuspendCallableReference.kt"); } + @Test @TestMetadata("simpleWithDefaultValue.kt") public void testSimpleWithDefaultValue() throws Exception { runTest("compiler/testData/codegen/box/coroutines/simpleWithDefaultValue.kt"); } + @Test @TestMetadata("simpleWithHandleResult.kt") public void testSimpleWithHandleResult() throws Exception { runTest("compiler/testData/codegen/box/coroutines/simpleWithHandleResult.kt"); } + @Test @TestMetadata("statementLikeLastExpression.kt") public void testStatementLikeLastExpression() throws Exception { runTest("compiler/testData/codegen/box/coroutines/statementLikeLastExpression.kt"); } + @Test @TestMetadata("stopAfter.kt") public void testStopAfter() throws Exception { runTest("compiler/testData/codegen/box/coroutines/stopAfter.kt"); } + @Test @TestMetadata("suspendCallsInArguments.kt") public void testSuspendCallsInArguments() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendCallsInArguments.kt"); } + @Test @TestMetadata("suspendCoroutineFromStateMachine.kt") public void testSuspendCoroutineFromStateMachine() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendCoroutineFromStateMachine.kt"); } + @Test @TestMetadata("suspendDefaultImpl.kt") public void testSuspendDefaultImpl() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendDefaultImpl.kt"); } + @Test @TestMetadata("suspendDelegation.kt") public void testSuspendDelegation() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendDelegation.kt"); } + @Test @TestMetadata("suspendFromInlineLambda.kt") public void testSuspendFromInlineLambda() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFromInlineLambda.kt"); } + @Test @TestMetadata("suspendFunImportedFromObject.kt") public void testSuspendFunImportedFromObject() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunImportedFromObject.kt"); } + @Test @TestMetadata("suspendFunctionAsSupertype.kt") public void testSuspendFunctionAsSupertype() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsSupertype.kt"); } + @Test @TestMetadata("suspendFunctionAsSupertypeCall.kt") public void testSuspendFunctionAsSupertypeCall() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsSupertypeCall.kt"); } + @Test @TestMetadata("suspendFunctionMethodReference.kt") public void testSuspendFunctionMethodReference() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunctionMethodReference.kt"); } + @Test @TestMetadata("suspendInCycle.kt") public void testSuspendInCycle() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendInCycle.kt"); } + @Test @TestMetadata("suspendInTheMiddleOfObjectConstruction.kt") public void testSuspendInTheMiddleOfObjectConstruction() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendInTheMiddleOfObjectConstruction.kt"); } + @Test @TestMetadata("suspendInTheMiddleOfObjectConstructionEvaluationOrder.kt") public void testSuspendInTheMiddleOfObjectConstructionEvaluationOrder() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendInTheMiddleOfObjectConstructionEvaluationOrder.kt"); } + @Test @TestMetadata("suspendInTheMiddleOfObjectConstructionWithJumpOut.kt") public void testSuspendInTheMiddleOfObjectConstructionWithJumpOut() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendInTheMiddleOfObjectConstructionWithJumpOut.kt"); } + @Test @TestMetadata("suspendInlineReference.kt") public void testSuspendInlineReference() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendInlineReference.kt"); } + @Test @TestMetadata("suspendLambdaInInterface.kt") public void testSuspendLambdaInInterface() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendLambdaInInterface.kt"); } + @Test @TestMetadata("suspendLambdaWithArgumentRearrangement.kt") public void testSuspendLambdaWithArgumentRearrangement() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendLambdaWithArgumentRearrangement.kt"); } + @Test @TestMetadata("suspensionInsideSafeCall.kt") public void testSuspensionInsideSafeCall() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspensionInsideSafeCall.kt"); } + @Test @TestMetadata("suspensionInsideSafeCallWithElvis.kt") public void testSuspensionInsideSafeCallWithElvis() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspensionInsideSafeCallWithElvis.kt"); } + @Test @TestMetadata("tailCallToNothing.kt") public void testTailCallToNothing() throws Exception { runTest("compiler/testData/codegen/box/coroutines/tailCallToNothing.kt"); } + @Test @TestMetadata("tryCatchFinallyWithHandleResult.kt") public void testTryCatchFinallyWithHandleResult() throws Exception { runTest("compiler/testData/codegen/box/coroutines/tryCatchFinallyWithHandleResult.kt"); } + @Test @TestMetadata("tryCatchWithHandleResult.kt") public void testTryCatchWithHandleResult() throws Exception { runTest("compiler/testData/codegen/box/coroutines/tryCatchWithHandleResult.kt"); } + @Test @TestMetadata("tryFinallyInsideInlineLambda.kt") public void testTryFinallyInsideInlineLambda() throws Exception { runTest("compiler/testData/codegen/box/coroutines/tryFinallyInsideInlineLambda.kt"); } + @Test @TestMetadata("tryFinallyWithHandleResult.kt") public void testTryFinallyWithHandleResult() throws Exception { runTest("compiler/testData/codegen/box/coroutines/tryFinallyWithHandleResult.kt"); } + @Test @TestMetadata("varCaptuedInCoroutineIntrinsic.kt") public void testVarCaptuedInCoroutineIntrinsic() throws Exception { runTest("compiler/testData/codegen/box/coroutines/varCaptuedInCoroutineIntrinsic.kt"); } + @Test @TestMetadata("varValueConflictsWithTable.kt") public void testVarValueConflictsWithTable() throws Exception { runTest("compiler/testData/codegen/box/coroutines/varValueConflictsWithTable.kt"); } + @Test @TestMetadata("varValueConflictsWithTableSameSort.kt") public void testVarValueConflictsWithTableSameSort() throws Exception { runTest("compiler/testData/codegen/box/coroutines/varValueConflictsWithTableSameSort.kt"); } + @Test @TestMetadata("varargCallFromSuspend.kt") public void testVarargCallFromSuspend() throws Exception { runTest("compiler/testData/codegen/box/coroutines/varargCallFromSuspend.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/bridges") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Bridges extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Bridges { + @Test public void testAllFilesPresentInBridges() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/bridges"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("interfaceGenericDefault.kt") public void testInterfaceGenericDefault() throws Exception { runTest("compiler/testData/codegen/box/coroutines/bridges/interfaceGenericDefault.kt"); } + @Test @TestMetadata("interfaceSpecialization.kt") public void testInterfaceSpecialization() throws Exception { runTest("compiler/testData/codegen/box/coroutines/bridges/interfaceSpecialization.kt"); } + @Test @TestMetadata("lambdaWithLongReceiver.kt") public void testLambdaWithLongReceiver() throws Exception { runTest("compiler/testData/codegen/box/coroutines/bridges/lambdaWithLongReceiver.kt"); } + @Test @TestMetadata("lambdaWithMultipleParameters.kt") public void testLambdaWithMultipleParameters() throws Exception { runTest("compiler/testData/codegen/box/coroutines/bridges/lambdaWithMultipleParameters.kt"); } + @Test @TestMetadata("mapSuspendAbstractClear.kt") public void testMapSuspendAbstractClear() throws Exception { runTest("compiler/testData/codegen/box/coroutines/bridges/mapSuspendAbstractClear.kt"); } + @Test @TestMetadata("mapSuspendClear.kt") public void testMapSuspendClear() throws Exception { runTest("compiler/testData/codegen/box/coroutines/bridges/mapSuspendClear.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/controlFlow") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ControlFlow extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ControlFlow { + @Test public void testAllFilesPresentInControlFlow() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/controlFlow"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("breakFinally.kt") public void testBreakFinally() throws Exception { runTest("compiler/testData/codegen/box/coroutines/controlFlow/breakFinally.kt"); } + @Test @TestMetadata("breakStatement.kt") public void testBreakStatement() throws Exception { runTest("compiler/testData/codegen/box/coroutines/controlFlow/breakStatement.kt"); } + @Test @TestMetadata("complexChainSuspend.kt") public void testComplexChainSuspend() throws Exception { runTest("compiler/testData/codegen/box/coroutines/controlFlow/complexChainSuspend.kt"); } + @Test @TestMetadata("doWhileStatement.kt") public void testDoWhileStatement() throws Exception { runTest("compiler/testData/codegen/box/coroutines/controlFlow/doWhileStatement.kt"); } + @Test @TestMetadata("doWhileWithInline.kt") public void testDoWhileWithInline() throws Exception { runTest("compiler/testData/codegen/box/coroutines/controlFlow/doWhileWithInline.kt"); } + @Test @TestMetadata("doubleBreak.kt") public void testDoubleBreak() throws Exception { runTest("compiler/testData/codegen/box/coroutines/controlFlow/doubleBreak.kt"); } + @Test @TestMetadata("finallyCatch.kt") public void testFinallyCatch() throws Exception { runTest("compiler/testData/codegen/box/coroutines/controlFlow/finallyCatch.kt"); } + @Test @TestMetadata("forContinue.kt") public void testForContinue() throws Exception { runTest("compiler/testData/codegen/box/coroutines/controlFlow/forContinue.kt"); } + @Test @TestMetadata("forStatement.kt") public void testForStatement() throws Exception { runTest("compiler/testData/codegen/box/coroutines/controlFlow/forStatement.kt"); } + @Test @TestMetadata("forWithStep.kt") public void testForWithStep() throws Exception { runTest("compiler/testData/codegen/box/coroutines/controlFlow/forWithStep.kt"); } + @Test @TestMetadata("ifStatement.kt") public void testIfStatement() throws Exception { runTest("compiler/testData/codegen/box/coroutines/controlFlow/ifStatement.kt"); } + @Test @TestMetadata("kt22694_1_3.kt") public void testKt22694_1_3() throws Exception { runTest("compiler/testData/codegen/box/coroutines/controlFlow/kt22694_1_3.kt"); } + @Test @TestMetadata("labeledWhile.kt") public void testLabeledWhile() throws Exception { runTest("compiler/testData/codegen/box/coroutines/controlFlow/labeledWhile.kt"); } + @Test @TestMetadata("multipleCatchBlocksSuspend.kt") public void testMultipleCatchBlocksSuspend() throws Exception { runTest("compiler/testData/codegen/box/coroutines/controlFlow/multipleCatchBlocksSuspend.kt"); } + @Test @TestMetadata("returnFromFinally.kt") public void testReturnFromFinally() throws Exception { runTest("compiler/testData/codegen/box/coroutines/controlFlow/returnFromFinally.kt"); } + @Test @TestMetadata("returnWithFinally.kt") public void testReturnWithFinally() throws Exception { runTest("compiler/testData/codegen/box/coroutines/controlFlow/returnWithFinally.kt"); } + @Test @TestMetadata("suspendInStringTemplate.kt") public void testSuspendInStringTemplate() throws Exception { runTest("compiler/testData/codegen/box/coroutines/controlFlow/suspendInStringTemplate.kt"); } + @Test @TestMetadata("switchLikeWhen.kt") public void testSwitchLikeWhen() throws Exception { runTest("compiler/testData/codegen/box/coroutines/controlFlow/switchLikeWhen.kt"); } + @Test @TestMetadata("throwFromCatch.kt") public void testThrowFromCatch() throws Exception { runTest("compiler/testData/codegen/box/coroutines/controlFlow/throwFromCatch.kt"); } + @Test @TestMetadata("throwFromFinally.kt") public void testThrowFromFinally() throws Exception { runTest("compiler/testData/codegen/box/coroutines/controlFlow/throwFromFinally.kt"); } + @Test @TestMetadata("throwInTryWithHandleResult.kt") public void testThrowInTryWithHandleResult() throws Exception { runTest("compiler/testData/codegen/box/coroutines/controlFlow/throwInTryWithHandleResult.kt"); } + @Test @TestMetadata("whenWithSuspensions.kt") public void testWhenWithSuspensions() throws Exception { runTest("compiler/testData/codegen/box/coroutines/controlFlow/whenWithSuspensions.kt"); } + @Test @TestMetadata("whileStatement.kt") public void testWhileStatement() throws Exception { runTest("compiler/testData/codegen/box/coroutines/controlFlow/whileStatement.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/debug") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Debug extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Debug { + @Test public void testAllFilesPresentInDebug() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/debug"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/featureIntersection") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class FeatureIntersection extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class FeatureIntersection { + @Test public void testAllFilesPresentInFeatureIntersection() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("breakWithNonEmptyStack.kt") public void testBreakWithNonEmptyStack() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/breakWithNonEmptyStack.kt"); } + @Test @TestMetadata("defaultExpect.kt") public void testDefaultExpect() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/defaultExpect.kt"); } + @Test @TestMetadata("delegate.kt") public void testDelegate() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/delegate.kt"); } + @Test @TestMetadata("destructuringInLambdas.kt") public void testDestructuringInLambdas() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/destructuringInLambdas.kt"); } + @Test @TestMetadata("funInterface.kt") public void testFunInterface() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/funInterface.kt"); } + @Test @TestMetadata("inlineSuspendFinally.kt") public void testInlineSuspendFinally() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/inlineSuspendFinally.kt"); } + @Test @TestMetadata("interfaceMethodWithBody.kt") public void testInterfaceMethodWithBody() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/interfaceMethodWithBody.kt"); } + @Test @TestMetadata("interfaceMethodWithBodyGeneric.kt") public void testInterfaceMethodWithBodyGeneric() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/interfaceMethodWithBodyGeneric.kt"); } + @Test @TestMetadata("overrideInInlineClass.kt") public void testOverrideInInlineClass() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/overrideInInlineClass.kt"); } + @Test @TestMetadata("overrideInInnerClass.kt") public void testOverrideInInnerClass() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/overrideInInnerClass.kt"); } + @Test @TestMetadata("safeCallOnTwoReceivers.kt") public void testSafeCallOnTwoReceivers() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/safeCallOnTwoReceivers.kt"); } + @Test @TestMetadata("safeCallOnTwoReceiversLong.kt") public void testSafeCallOnTwoReceiversLong() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/safeCallOnTwoReceiversLong.kt"); } + @Test @TestMetadata("suspendDestructuringInLambdas.kt") public void testSuspendDestructuringInLambdas() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/suspendDestructuringInLambdas.kt"); } + @Test @TestMetadata("suspendFunctionAsSupertypeIsCheckWithArity.kt") public void testSuspendFunctionAsSupertypeIsCheckWithArity() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/suspendFunctionAsSupertypeIsCheckWithArity.kt"); } + @Test @TestMetadata("suspendFunctionIsAs.kt") public void testSuspendFunctionIsAs() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/suspendFunctionIsAs.kt"); } + @Test @TestMetadata("suspendInlineSuspendFinally.kt") public void testSuspendInlineSuspendFinally() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/suspendInlineSuspendFinally.kt"); } + @Test @TestMetadata("suspendOperatorPlus.kt") public void testSuspendOperatorPlus() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/suspendOperatorPlus.kt"); } + @Test @TestMetadata("suspendOperatorPlusAssign.kt") public void testSuspendOperatorPlusAssign() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/suspendOperatorPlusAssign.kt"); } + @Test @TestMetadata("suspendOperatorPlusCallFromLambda.kt") public void testSuspendOperatorPlusCallFromLambda() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/suspendOperatorPlusCallFromLambda.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class CallableReference extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class CallableReference { + @Test public void testAllFilesPresentInCallableReference() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("bigArity.kt") public void testBigArity() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/bigArity.kt"); } + @Test @TestMetadata("lambdaParameterUsed.kt") public void testLambdaParameterUsed() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/lambdaParameterUsed.kt"); } + @Test @TestMetadata("longArgs.kt") public void testLongArgs() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/longArgs.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/bound") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Bound extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Bound { + @Test public void testAllFilesPresentInBound() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/bound"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("emptyLHS.kt") public void testEmptyLHS() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/bound/emptyLHS.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Function extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Function { + @Test @TestMetadata("adapted.kt") public void testAdapted() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/adapted.kt"); } + @Test public void testAllFilesPresentInFunction() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("genericCallableReferencesWithNullableTypes.kt") public void testGenericCallableReferencesWithNullableTypes() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/genericCallableReferencesWithNullableTypes.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/local") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Local extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Local { + @Test public void testAllFilesPresentInLocal() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/local"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("equalsHashCode.kt") public void testEqualsHashCode() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/local/equalsHashCode.kt"); @@ -7155,142 +8116,148 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/featureIntersection/funInterface") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class FunInterface extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class FunInterface { + @Test public void testAllFilesPresentInFunInterface() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/funInterface"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt47549.kt") public void testKt47549() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/funInterface/kt47549.kt"); } + @Test @TestMetadata("kt47549_1.kt") public void testKt47549_1() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/funInterface/kt47549_1.kt"); } + @Test @TestMetadata("kt49294.kt") public void testKt49294() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/funInterface/kt49294.kt"); } + @Test @TestMetadata("kt50950.kt") public void testKt50950() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/funInterface/kt50950.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/featureIntersection/jvmDefault") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class JvmDefault extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class JvmDefault { + @Test public void testAllFilesPresentInJvmDefault() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/jvmDefault"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/featureIntersection/jvmDefault/kt46007") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Kt46007 extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Kt46007 { + @Test public void testAllFilesPresentInKt46007() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/jvmDefault/kt46007"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Tailrec extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Tailrec { + @Test public void testAllFilesPresentInTailrec() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("controlFlowIf.kt") public void testControlFlowIf() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/controlFlowIf.kt"); } + @Test @TestMetadata("controlFlowWhen.kt") public void testControlFlowWhen() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/controlFlowWhen.kt"); } + @Test @TestMetadata("extention.kt") public void testExtention() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/extention.kt"); } + @Test @TestMetadata("infixCall.kt") public void testInfixCall() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/infixCall.kt"); } + @Test @TestMetadata("infixRecursiveCall.kt") public void testInfixRecursiveCall() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/infixRecursiveCall.kt"); } + @Test @TestMetadata("kt38920_localTailrec.kt") public void testKt38920_localTailrec() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/kt38920_localTailrec.kt"); } + @Test @TestMetadata("realIteratorFoldl.kt") public void testRealIteratorFoldl() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/realIteratorFoldl.kt"); } + @Test @TestMetadata("realStringEscape.kt") public void testRealStringEscape() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/realStringEscape.kt"); } + @Test @TestMetadata("realStringRepeat.kt") public void testRealStringRepeat() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/realStringRepeat.kt"); } + @Test @TestMetadata("returnInParentheses.kt") public void testReturnInParentheses() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/returnInParentheses.kt"); } + @Test @TestMetadata("sum.kt") public void testSum() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/sum.kt"); } + @Test @TestMetadata("tailCallInBlockInParentheses.kt") public void testTailCallInBlockInParentheses() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/tailCallInBlockInParentheses.kt"); } + @Test @TestMetadata("tailCallInParentheses.kt") public void testTailCallInParentheses() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/tailCallInParentheses.kt"); } + @Test @TestMetadata("whenWithIs.kt") public void testWhenWithIs() throws Exception { runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/whenWithIs.kt"); @@ -7298,746 +8265,873 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/inlineClasses") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class InlineClasses extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class InlineClasses { + @Test public void testAllFilesPresentInInlineClasses() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("genericParameterResult.kt") public void testGenericParameterResult() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericParameterResult.kt"); } + @Test @TestMetadata("kt47129.kt") public void testKt47129() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/kt47129.kt"); } + @Test @TestMetadata("nonLocalReturn.kt") public void testNonLocalReturn() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/nonLocalReturn.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/inlineClasses/direct") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Direct extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Direct { + @Test public void testAllFilesPresentInDirect() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/direct"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") public void testBoxReturnValueOfSuspendFunctionReference() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxReturnValueOfSuspendFunctionReference.kt"); } + @Test @TestMetadata("boxReturnValueOfSuspendLambda.kt") public void testBoxReturnValueOfSuspendLambda() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxReturnValueOfSuspendLambda.kt"); } + @Test @TestMetadata("boxTypeParameterOfSuperType.kt") public void testBoxTypeParameterOfSuperType() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxTypeParameterOfSuperType.kt"); } + @Test @TestMetadata("boxTypeParameterOfSuperTypeResult.kt") public void testBoxTypeParameterOfSuperTypeResult() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxTypeParameterOfSuperTypeResult.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine.kt") public void testBoxUnboxInsideCoroutine() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxUnboxInsideCoroutine.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine_Any.kt") public void testBoxUnboxInsideCoroutine_Any() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxUnboxInsideCoroutine_Any.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine_InlineAny.kt") public void testBoxUnboxInsideCoroutine_InlineAny() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxUnboxInsideCoroutine_InlineAny.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine_InlineInt.kt") public void testBoxUnboxInsideCoroutine_InlineInt() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxUnboxInsideCoroutine_InlineInt.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine_Int.kt") public void testBoxUnboxInsideCoroutine_Int() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxUnboxInsideCoroutine_Int.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine_Long.kt") public void testBoxUnboxInsideCoroutine_Long() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxUnboxInsideCoroutine_Long.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine_NAny.kt") public void testBoxUnboxInsideCoroutine_NAny() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxUnboxInsideCoroutine_NAny.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine_nonLocalReturn.kt") public void testBoxUnboxInsideCoroutine_nonLocalReturn() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxUnboxInsideCoroutine_nonLocalReturn.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine_suspendFunType.kt") public void testBoxUnboxInsideCoroutine_suspendFunType() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxUnboxInsideCoroutine_suspendFunType.kt"); } + @Test @TestMetadata("bridgeGenerationCrossinline.kt") public void testBridgeGenerationCrossinline() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/bridgeGenerationCrossinline.kt"); } + @Test @TestMetadata("bridgeGenerationNonInline.kt") public void testBridgeGenerationNonInline() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/bridgeGenerationNonInline.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFun.kt") public void testCovariantOverrideSuspendFun() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFun.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunSameJvmType.kt") public void testCovariantOverrideSuspendFunSameJvmType() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFunSameJvmType.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass.kt") public void testCovariantOverrideSuspendFunWithNullableInlineClass() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFunWithNullableInlineClass.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClassSameJvmType.kt") public void testCovariantOverrideSuspendFunWithNullableInlineClassSameJvmType() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFunWithNullableInlineClassSameJvmType.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_Any.kt") public void testCovariantOverrideSuspendFunWithNullableInlineClass_Any() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFunWithNullableInlineClass_Any.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_Int.kt") public void testCovariantOverrideSuspendFunWithNullableInlineClass_Int() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFunWithNullableInlineClass_Int.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt") public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableAny() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt") public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt") public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableInt() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null.kt") public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFun_Any.kt") public void testCovariantOverrideSuspendFun_Any() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFun_Any.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFun_Int.kt") public void testCovariantOverrideSuspendFun_Int() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFun_Int.kt"); } + @Test @TestMetadata("createMangling.kt") public void testCreateMangling() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/createMangling.kt"); } + @Test @TestMetadata("createOverride.kt") public void testCreateOverride() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/createOverride.kt"); } + @Test @TestMetadata("defaultStub.kt") public void testDefaultStub() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/defaultStub.kt"); } + @Test @TestMetadata("genericOverrideSuspendFun.kt") public void testGenericOverrideSuspendFun() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/genericOverrideSuspendFun.kt"); } + @Test @TestMetadata("genericOverrideSuspendFun_Any.kt") public void testGenericOverrideSuspendFun_Any() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/genericOverrideSuspendFun_Any.kt"); } + @Test @TestMetadata("genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt") public void testGenericOverrideSuspendFun_Any_NullableInlineClassUpperBound() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt"); } + @Test @TestMetadata("genericOverrideSuspendFun_Int.kt") public void testGenericOverrideSuspendFun_Int() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/genericOverrideSuspendFun_Int.kt"); } + @Test @TestMetadata("genericOverrideSuspendFun_NullableAny.kt") public void testGenericOverrideSuspendFun_NullableAny() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/genericOverrideSuspendFun_NullableAny.kt"); } + @Test @TestMetadata("genericOverrideSuspendFun_NullableAny_null.kt") public void testGenericOverrideSuspendFun_NullableAny_null() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/genericOverrideSuspendFun_NullableAny_null.kt"); } + @Test @TestMetadata("genericOverrideSuspendFun_NullableInt.kt") public void testGenericOverrideSuspendFun_NullableInt() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/genericOverrideSuspendFun_NullableInt.kt"); } + @Test @TestMetadata("genericOverrideSuspendFun_NullableInt_null.kt") public void testGenericOverrideSuspendFun_NullableInt_null() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/genericOverrideSuspendFun_NullableInt_null.kt"); } + @Test @TestMetadata("interfaceDelegateWithInlineClass.kt") public void testInterfaceDelegateWithInlineClass() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/interfaceDelegateWithInlineClass.kt"); } + @Test @TestMetadata("invokeOperator.kt") public void testInvokeOperator() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/invokeOperator.kt"); } + @Test @TestMetadata("overrideSuspendFun.kt") public void testOverrideSuspendFun() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/overrideSuspendFun.kt"); } + @Test @TestMetadata("overrideSuspendFun_Any.kt") public void testOverrideSuspendFun_Any() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/overrideSuspendFun_Any.kt"); } + @Test @TestMetadata("overrideSuspendFun_Any_itf.kt") public void testOverrideSuspendFun_Any_itf() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/overrideSuspendFun_Any_itf.kt"); } + @Test @TestMetadata("overrideSuspendFun_Any_this.kt") public void testOverrideSuspendFun_Any_this() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/overrideSuspendFun_Any_this.kt"); } + @Test @TestMetadata("overrideSuspendFun_Int.kt") public void testOverrideSuspendFun_Int() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/overrideSuspendFun_Int.kt"); } + @Test @TestMetadata("returnResult.kt") public void testReturnResult() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/returnResult.kt"); } + @Test @TestMetadata("syntheticAccessor.kt") public void testSyntheticAccessor() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/syntheticAccessor.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/inlineClasses/resume") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Resume extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Resume { + @Test public void testAllFilesPresentInResume() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resume"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") public void testBoxReturnValueOfSuspendFunctionReference() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxReturnValueOfSuspendFunctionReference.kt"); } + @Test @TestMetadata("boxReturnValueOfSuspendLambda.kt") public void testBoxReturnValueOfSuspendLambda() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxReturnValueOfSuspendLambda.kt"); } + @Test @TestMetadata("boxTypeParameterOfSuperType.kt") public void testBoxTypeParameterOfSuperType() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxTypeParameterOfSuperType.kt"); } + @Test @TestMetadata("boxTypeParameterOfSuperTypeResult.kt") public void testBoxTypeParameterOfSuperTypeResult() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxTypeParameterOfSuperTypeResult.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine.kt") public void testBoxUnboxInsideCoroutine() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxUnboxInsideCoroutine.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine_Any.kt") public void testBoxUnboxInsideCoroutine_Any() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxUnboxInsideCoroutine_Any.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine_InlineAny.kt") public void testBoxUnboxInsideCoroutine_InlineAny() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxUnboxInsideCoroutine_InlineAny.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine_InlineInt.kt") public void testBoxUnboxInsideCoroutine_InlineInt() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxUnboxInsideCoroutine_InlineInt.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine_Int.kt") public void testBoxUnboxInsideCoroutine_Int() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxUnboxInsideCoroutine_Int.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine_Long.kt") public void testBoxUnboxInsideCoroutine_Long() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxUnboxInsideCoroutine_Long.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine_NAny.kt") public void testBoxUnboxInsideCoroutine_NAny() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxUnboxInsideCoroutine_NAny.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine_nonLocalReturn.kt") public void testBoxUnboxInsideCoroutine_nonLocalReturn() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxUnboxInsideCoroutine_nonLocalReturn.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine_suspendFunType.kt") public void testBoxUnboxInsideCoroutine_suspendFunType() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxUnboxInsideCoroutine_suspendFunType.kt"); } + @Test @TestMetadata("bridgeGenerationCrossinline.kt") public void testBridgeGenerationCrossinline() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/bridgeGenerationCrossinline.kt"); } + @Test @TestMetadata("bridgeGenerationNonInline.kt") public void testBridgeGenerationNonInline() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/bridgeGenerationNonInline.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFun.kt") public void testCovariantOverrideSuspendFun() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFun.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunSameJvmType.kt") public void testCovariantOverrideSuspendFunSameJvmType() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFunSameJvmType.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass.kt") public void testCovariantOverrideSuspendFunWithNullableInlineClass() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFunWithNullableInlineClass.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClassSameJvmType.kt") public void testCovariantOverrideSuspendFunWithNullableInlineClassSameJvmType() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFunWithNullableInlineClassSameJvmType.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_Any.kt") public void testCovariantOverrideSuspendFunWithNullableInlineClass_Any() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFunWithNullableInlineClass_Any.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_Int.kt") public void testCovariantOverrideSuspendFunWithNullableInlineClass_Int() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFunWithNullableInlineClass_Int.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt") public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableAny() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt") public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt") public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableInt() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null.kt") public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFun_Any.kt") public void testCovariantOverrideSuspendFun_Any() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFun_Any.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFun_Int.kt") public void testCovariantOverrideSuspendFun_Int() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFun_Int.kt"); } + @Test @TestMetadata("createMangling.kt") public void testCreateMangling() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/createMangling.kt"); } + @Test @TestMetadata("createOverride.kt") public void testCreateOverride() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/createOverride.kt"); } + @Test @TestMetadata("defaultStub.kt") public void testDefaultStub() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/defaultStub.kt"); } + @Test @TestMetadata("genericOverrideSuspendFun.kt") public void testGenericOverrideSuspendFun() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/genericOverrideSuspendFun.kt"); } + @Test @TestMetadata("genericOverrideSuspendFun_Any.kt") public void testGenericOverrideSuspendFun_Any() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/genericOverrideSuspendFun_Any.kt"); } + @Test @TestMetadata("genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt") public void testGenericOverrideSuspendFun_Any_NullableInlineClassUpperBound() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt"); } + @Test @TestMetadata("genericOverrideSuspendFun_Int.kt") public void testGenericOverrideSuspendFun_Int() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/genericOverrideSuspendFun_Int.kt"); } + @Test @TestMetadata("genericOverrideSuspendFun_NullableAny.kt") public void testGenericOverrideSuspendFun_NullableAny() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/genericOverrideSuspendFun_NullableAny.kt"); } + @Test @TestMetadata("genericOverrideSuspendFun_NullableAny_null.kt") public void testGenericOverrideSuspendFun_NullableAny_null() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/genericOverrideSuspendFun_NullableAny_null.kt"); } + @Test @TestMetadata("genericOverrideSuspendFun_NullableInt.kt") public void testGenericOverrideSuspendFun_NullableInt() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/genericOverrideSuspendFun_NullableInt.kt"); } + @Test @TestMetadata("genericOverrideSuspendFun_NullableInt_null.kt") public void testGenericOverrideSuspendFun_NullableInt_null() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/genericOverrideSuspendFun_NullableInt_null.kt"); } + @Test @TestMetadata("interfaceDelegateWithInlineClass.kt") public void testInterfaceDelegateWithInlineClass() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/interfaceDelegateWithInlineClass.kt"); } + @Test @TestMetadata("invokeOperator.kt") public void testInvokeOperator() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/invokeOperator.kt"); } + @Test @TestMetadata("overrideSuspendFun.kt") public void testOverrideSuspendFun() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/overrideSuspendFun.kt"); } + @Test @TestMetadata("overrideSuspendFun_Any.kt") public void testOverrideSuspendFun_Any() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/overrideSuspendFun_Any.kt"); } + @Test @TestMetadata("overrideSuspendFun_Any_itf.kt") public void testOverrideSuspendFun_Any_itf() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/overrideSuspendFun_Any_itf.kt"); } + @Test @TestMetadata("overrideSuspendFun_Any_this.kt") public void testOverrideSuspendFun_Any_this() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/overrideSuspendFun_Any_this.kt"); } + @Test @TestMetadata("overrideSuspendFun_Int.kt") public void testOverrideSuspendFun_Int() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/overrideSuspendFun_Int.kt"); } + @Test @TestMetadata("returnResult.kt") public void testReturnResult() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/returnResult.kt"); } + @Test @TestMetadata("syntheticAccessor.kt") public void testSyntheticAccessor() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/syntheticAccessor.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ResumeWithException extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ResumeWithException { + @Test public void testAllFilesPresentInResumeWithException() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") public void testBoxReturnValueOfSuspendFunctionReference() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxReturnValueOfSuspendFunctionReference.kt"); } + @Test @TestMetadata("boxReturnValueOfSuspendLambda.kt") public void testBoxReturnValueOfSuspendLambda() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxReturnValueOfSuspendLambda.kt"); } + @Test @TestMetadata("boxTypeParameterOfSuperType.kt") public void testBoxTypeParameterOfSuperType() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxTypeParameterOfSuperType.kt"); } + @Test @TestMetadata("boxTypeParameterOfSuperTypeResult.kt") public void testBoxTypeParameterOfSuperTypeResult() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxTypeParameterOfSuperTypeResult.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine.kt") public void testBoxUnboxInsideCoroutine() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxUnboxInsideCoroutine.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine_Any.kt") public void testBoxUnboxInsideCoroutine_Any() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxUnboxInsideCoroutine_Any.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine_InlineAny.kt") public void testBoxUnboxInsideCoroutine_InlineAny() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxUnboxInsideCoroutine_InlineAny.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine_InlineInt.kt") public void testBoxUnboxInsideCoroutine_InlineInt() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxUnboxInsideCoroutine_InlineInt.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine_Int.kt") public void testBoxUnboxInsideCoroutine_Int() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxUnboxInsideCoroutine_Int.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine_Long.kt") public void testBoxUnboxInsideCoroutine_Long() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxUnboxInsideCoroutine_Long.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine_NAny.kt") public void testBoxUnboxInsideCoroutine_NAny() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxUnboxInsideCoroutine_NAny.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine_nonLocalReturn.kt") public void testBoxUnboxInsideCoroutine_nonLocalReturn() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxUnboxInsideCoroutine_nonLocalReturn.kt"); } + @Test @TestMetadata("boxUnboxInsideCoroutine_suspendFunType.kt") public void testBoxUnboxInsideCoroutine_suspendFunType() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxUnboxInsideCoroutine_suspendFunType.kt"); } + @Test @TestMetadata("bridgeGenerationCrossinline.kt") public void testBridgeGenerationCrossinline() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/bridgeGenerationCrossinline.kt"); } + @Test @TestMetadata("bridgeGenerationNonInline.kt") public void testBridgeGenerationNonInline() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/bridgeGenerationNonInline.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFun.kt") public void testCovariantOverrideSuspendFun() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFun.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunSameJvmType.kt") public void testCovariantOverrideSuspendFunSameJvmType() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFunSameJvmType.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass.kt") public void testCovariantOverrideSuspendFunWithNullableInlineClass() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFunWithNullableInlineClass.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClassSameJvmType.kt") public void testCovariantOverrideSuspendFunWithNullableInlineClassSameJvmType() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFunWithNullableInlineClassSameJvmType.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_Any.kt") public void testCovariantOverrideSuspendFunWithNullableInlineClass_Any() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFunWithNullableInlineClass_Any.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_Int.kt") public void testCovariantOverrideSuspendFunWithNullableInlineClass_Int() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFunWithNullableInlineClass_Int.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt") public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableAny() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt") public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt") public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableInt() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFun_Any.kt") public void testCovariantOverrideSuspendFun_Any() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFun_Any.kt"); } + @Test @TestMetadata("covariantOverrideSuspendFun_Int.kt") public void testCovariantOverrideSuspendFun_Int() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFun_Int.kt"); } + @Test @TestMetadata("createMangling.kt") public void testCreateMangling() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/createMangling.kt"); } + @Test @TestMetadata("createOverride.kt") public void testCreateOverride() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/createOverride.kt"); } + @Test @TestMetadata("genericOverrideSuspendFun.kt") public void testGenericOverrideSuspendFun() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/genericOverrideSuspendFun.kt"); } + @Test @TestMetadata("genericOverrideSuspendFun_Any.kt") public void testGenericOverrideSuspendFun_Any() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/genericOverrideSuspendFun_Any.kt"); } + @Test @TestMetadata("genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt") public void testGenericOverrideSuspendFun_Any_NullableInlineClassUpperBound() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt"); } + @Test @TestMetadata("genericOverrideSuspendFun_Int.kt") public void testGenericOverrideSuspendFun_Int() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/genericOverrideSuspendFun_Int.kt"); } + @Test @TestMetadata("genericOverrideSuspendFun_NullableAny.kt") public void testGenericOverrideSuspendFun_NullableAny() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/genericOverrideSuspendFun_NullableAny.kt"); } + @Test @TestMetadata("genericOverrideSuspendFun_NullableInt.kt") public void testGenericOverrideSuspendFun_NullableInt() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/genericOverrideSuspendFun_NullableInt.kt"); } + @Test @TestMetadata("interfaceDelegateWithInlineClass.kt") public void testInterfaceDelegateWithInlineClass() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/interfaceDelegateWithInlineClass.kt"); } + @Test @TestMetadata("invokeOperator.kt") public void testInvokeOperator() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/invokeOperator.kt"); } + @Test @TestMetadata("overrideSuspendFun.kt") public void testOverrideSuspendFun() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/overrideSuspendFun.kt"); } + @Test @TestMetadata("overrideSuspendFun_Any.kt") public void testOverrideSuspendFun_Any() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/overrideSuspendFun_Any.kt"); } + @Test @TestMetadata("overrideSuspendFun_Any_itf.kt") public void testOverrideSuspendFun_Any_itf() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/overrideSuspendFun_Any_itf.kt"); } + @Test @TestMetadata("overrideSuspendFun_Any_this.kt") public void testOverrideSuspendFun_Any_this() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/overrideSuspendFun_Any_this.kt"); } + @Test @TestMetadata("overrideSuspendFun_Int.kt") public void testOverrideSuspendFun_Int() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/overrideSuspendFun_Int.kt"); } + @Test @TestMetadata("returnResult.kt") public void testReturnResult() throws Exception { runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/returnResult.kt"); @@ -8045,224 +9139,241 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/intLikeVarSpilling") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class IntLikeVarSpilling extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class IntLikeVarSpilling { + @Test public void testAllFilesPresentInIntLikeVarSpilling() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intLikeVarSpilling"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("complicatedMerge.kt") public void testComplicatedMerge() throws Exception { runTest("compiler/testData/codegen/box/coroutines/intLikeVarSpilling/complicatedMerge.kt"); } + @Test @TestMetadata("i2bResult.kt") public void testI2bResult() throws Exception { runTest("compiler/testData/codegen/box/coroutines/intLikeVarSpilling/i2bResult.kt"); } + @Test @TestMetadata("listThrowablePairInOneSlot.kt") public void testListThrowablePairInOneSlot() throws Exception { runTest("compiler/testData/codegen/box/coroutines/intLikeVarSpilling/listThrowablePairInOneSlot.kt"); } + @Test @TestMetadata("loadFromBooleanArray.kt") public void testLoadFromBooleanArray() throws Exception { runTest("compiler/testData/codegen/box/coroutines/intLikeVarSpilling/loadFromBooleanArray.kt"); } + @Test @TestMetadata("loadFromByteArray.kt") public void testLoadFromByteArray() throws Exception { runTest("compiler/testData/codegen/box/coroutines/intLikeVarSpilling/loadFromByteArray.kt"); } + @Test @TestMetadata("noVariableInTable.kt") public void testNoVariableInTable() throws Exception { runTest("compiler/testData/codegen/box/coroutines/intLikeVarSpilling/noVariableInTable.kt"); } + @Test @TestMetadata("sameIconst1ManyVars.kt") public void testSameIconst1ManyVars() throws Exception { runTest("compiler/testData/codegen/box/coroutines/intLikeVarSpilling/sameIconst1ManyVars.kt"); } + @Test @TestMetadata("unusedCatchVar.kt") public void testUnusedCatchVar() throws Exception { runTest("compiler/testData/codegen/box/coroutines/intLikeVarSpilling/unusedCatchVar.kt"); } + @Test @TestMetadata("usedInMethodCall.kt") public void testUsedInMethodCall() throws Exception { runTest("compiler/testData/codegen/box/coroutines/intLikeVarSpilling/usedInMethodCall.kt"); } + @Test @TestMetadata("usedInVarStore.kt") public void testUsedInVarStore() throws Exception { runTest("compiler/testData/codegen/box/coroutines/intLikeVarSpilling/usedInVarStore.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/intrinsicSemantics") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class IntrinsicSemantics extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class IntrinsicSemantics { + @Test public void testAllFilesPresentInIntrinsicSemantics() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intrinsicSemantics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("coroutineContext.kt") public void testCoroutineContext() throws Exception { runTest("compiler/testData/codegen/box/coroutines/intrinsicSemantics/coroutineContext.kt"); } + @Test @TestMetadata("coroutineContextReceiver.kt") public void testCoroutineContextReceiver() throws Exception { runTest("compiler/testData/codegen/box/coroutines/intrinsicSemantics/coroutineContextReceiver.kt"); } + @Test @TestMetadata("coroutineContextReceiverNotIntrinsic.kt") public void testCoroutineContextReceiverNotIntrinsic() throws Exception { runTest("compiler/testData/codegen/box/coroutines/intrinsicSemantics/coroutineContextReceiverNotIntrinsic.kt"); } + @Test @TestMetadata("intercepted.kt") public void testIntercepted() throws Exception { runTest("compiler/testData/codegen/box/coroutines/intrinsicSemantics/intercepted.kt"); } + @Test @TestMetadata("releaseIntercepted.kt") public void testReleaseIntercepted() throws Exception { runTest("compiler/testData/codegen/box/coroutines/intrinsicSemantics/releaseIntercepted.kt"); } + @Test @TestMetadata("resultExceptionOrNullInLambda.kt") public void testResultExceptionOrNullInLambda() throws Exception { runTest("compiler/testData/codegen/box/coroutines/intrinsicSemantics/resultExceptionOrNullInLambda.kt"); } + @Test @TestMetadata("startCoroutine.kt") public void testStartCoroutine() throws Exception { runTest("compiler/testData/codegen/box/coroutines/intrinsicSemantics/startCoroutine.kt"); } + @Test @TestMetadata("startCoroutineUninterceptedOrReturn.kt") public void testStartCoroutineUninterceptedOrReturn() throws Exception { runTest("compiler/testData/codegen/box/coroutines/intrinsicSemantics/startCoroutineUninterceptedOrReturn.kt"); } + @Test @TestMetadata("startCoroutineUninterceptedOrReturnInterception.kt") public void testStartCoroutineUninterceptedOrReturnInterception() throws Exception { runTest("compiler/testData/codegen/box/coroutines/intrinsicSemantics/startCoroutineUninterceptedOrReturnInterception.kt"); } + @Test @TestMetadata("suspendCoroutineUninterceptedOrReturn.kt") public void testSuspendCoroutineUninterceptedOrReturn() throws Exception { runTest("compiler/testData/codegen/box/coroutines/intrinsicSemantics/suspendCoroutineUninterceptedOrReturn.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/javaInterop") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class JavaInterop extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class JavaInterop { + @Test public void testAllFilesPresentInJavaInterop() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/javaInterop"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/localFunctions") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class LocalFunctions extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class LocalFunctions { + @Test public void testAllFilesPresentInLocalFunctions() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/localFunctions/named") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Named extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Named { + @Test public void testAllFilesPresentInNamed() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/named"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("callTopLevelFromLocal.kt") public void testCallTopLevelFromLocal() throws Exception { runTest("compiler/testData/codegen/box/coroutines/localFunctions/named/callTopLevelFromLocal.kt"); } + @Test @TestMetadata("capturedParameters.kt") public void testCapturedParameters() throws Exception { runTest("compiler/testData/codegen/box/coroutines/localFunctions/named/capturedParameters.kt"); } + @Test @TestMetadata("capturedVariables.kt") public void testCapturedVariables() throws Exception { runTest("compiler/testData/codegen/box/coroutines/localFunctions/named/capturedVariables.kt"); } + @Test @TestMetadata("defaultArgument.kt") public void testDefaultArgument() throws Exception { runTest("compiler/testData/codegen/box/coroutines/localFunctions/named/defaultArgument.kt"); } + @Test @TestMetadata("extension.kt") public void testExtension() throws Exception { runTest("compiler/testData/codegen/box/coroutines/localFunctions/named/extension.kt"); } + @Test @TestMetadata("infix.kt") public void testInfix() throws Exception { runTest("compiler/testData/codegen/box/coroutines/localFunctions/named/infix.kt"); } + @Test @TestMetadata("insideLambda.kt") public void testInsideLambda() throws Exception { runTest("compiler/testData/codegen/box/coroutines/localFunctions/named/insideLambda.kt"); } + @Test @TestMetadata("nestedLocals.kt") public void testNestedLocals() throws Exception { runTest("compiler/testData/codegen/box/coroutines/localFunctions/named/nestedLocals.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/coroutines/localFunctions/named/simple.kt"); } + @Test @TestMetadata("simpleSuspensionPoint.kt") public void testSimpleSuspensionPoint() throws Exception { runTest("compiler/testData/codegen/box/coroutines/localFunctions/named/simpleSuspensionPoint.kt"); } + @Test @TestMetadata("stateMachine.kt") public void testStateMachine() throws Exception { runTest("compiler/testData/codegen/box/coroutines/localFunctions/named/stateMachine.kt"); } + @Test @TestMetadata("withArguments.kt") public void testWithArguments() throws Exception { runTest("compiler/testData/codegen/box/coroutines/localFunctions/named/withArguments.kt"); @@ -8270,507 +9381,530 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/multiModule") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class MultiModule extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class MultiModule { + @Test public void testAllFilesPresentInMultiModule() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/multiModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("inheritFromAnotherModule.kt") public void testInheritFromAnotherModule() throws Exception { runTest("compiler/testData/codegen/box/coroutines/multiModule/inheritFromAnotherModule.kt"); } + @Test @TestMetadata("inlineCrossModule.kt") public void testInlineCrossModule() throws Exception { runTest("compiler/testData/codegen/box/coroutines/multiModule/inlineCrossModule.kt"); } + @Test @TestMetadata("inlineFunctionWithOptionalParam.kt") public void testInlineFunctionWithOptionalParam() throws Exception { runTest("compiler/testData/codegen/box/coroutines/multiModule/inlineFunctionWithOptionalParam.kt"); } + @Test @TestMetadata("inlineMultiModule.kt") public void testInlineMultiModule() throws Exception { runTest("compiler/testData/codegen/box/coroutines/multiModule/inlineMultiModule.kt"); } + @Test @TestMetadata("inlineMultiModuleOverride.kt") public void testInlineMultiModuleOverride() throws Exception { runTest("compiler/testData/codegen/box/coroutines/multiModule/inlineMultiModuleOverride.kt"); } + @Test @TestMetadata("inlineMultiModuleWithController.kt") public void testInlineMultiModuleWithController() throws Exception { runTest("compiler/testData/codegen/box/coroutines/multiModule/inlineMultiModuleWithController.kt"); } + @Test @TestMetadata("inlineMultiModuleWithInnerInlining.kt") public void testInlineMultiModuleWithInnerInlining() throws Exception { runTest("compiler/testData/codegen/box/coroutines/multiModule/inlineMultiModuleWithInnerInlining.kt"); } + @Test @TestMetadata("inlineTailCall.kt") public void testInlineTailCall() throws Exception { runTest("compiler/testData/codegen/box/coroutines/multiModule/inlineTailCall.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/coroutines/multiModule/simple.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/redundantLocalsElimination") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class RedundantLocalsElimination extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class RedundantLocalsElimination { + @Test public void testAllFilesPresentInRedundantLocalsElimination() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/redundantLocalsElimination"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("ktor_receivedMessage.kt") public void testKtor_receivedMessage() throws Exception { runTest("compiler/testData/codegen/box/coroutines/redundantLocalsElimination/ktor_receivedMessage.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/reflect") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Reflect extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Reflect { + @Test public void testAllFilesPresentInReflect() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/reflect"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/stackUnwinding") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class StackUnwinding extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class StackUnwinding { + @Test public void testAllFilesPresentInStackUnwinding() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/stackUnwinding"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("exception.kt") public void testException() throws Exception { runTest("compiler/testData/codegen/box/coroutines/stackUnwinding/exception.kt"); } + @Test @TestMetadata("inlineSuspendFunction.kt") public void testInlineSuspendFunction() throws Exception { runTest("compiler/testData/codegen/box/coroutines/stackUnwinding/inlineSuspendFunction.kt"); } + @Test @TestMetadata("rethrowInFinally.kt") public void testRethrowInFinally() throws Exception { runTest("compiler/testData/codegen/box/coroutines/stackUnwinding/rethrowInFinally.kt"); } + @Test @TestMetadata("rethrowInFinallyWithSuspension.kt") public void testRethrowInFinallyWithSuspension() throws Exception { runTest("compiler/testData/codegen/box/coroutines/stackUnwinding/rethrowInFinallyWithSuspension.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/coroutines/stackUnwinding/simple.kt"); } + @Test @TestMetadata("suspendInCycle.kt") public void testSuspendInCycle() throws Exception { runTest("compiler/testData/codegen/box/coroutines/stackUnwinding/suspendInCycle.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/suspendConversion") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SuspendConversion extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class SuspendConversion { + @Test public void testAllFilesPresentInSuspendConversion() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendConversion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("intersectionTypeToSubtypeConversion.kt") public void testIntersectionTypeToSubtypeConversion() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendConversion/intersectionTypeToSubtypeConversion.kt"); } + @Test @TestMetadata("onArgument.kt") public void testOnArgument() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendConversion/onArgument.kt"); } + @Test @TestMetadata("onInlineArgument.kt") public void testOnInlineArgument() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendConversion/onInlineArgument.kt"); } + @Test @TestMetadata("subtypeOfFunctionalTypeToSuspendConversion.kt") public void testSubtypeOfFunctionalTypeToSuspendConversion() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendConversion/subtypeOfFunctionalTypeToSuspendConversion.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SuspendFunctionAsCoroutine extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class SuspendFunctionAsCoroutine { + @Test public void testAllFilesPresentInSuspendFunctionAsCoroutine() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("dispatchResume.kt") public void testDispatchResume() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/dispatchResume.kt"); } + @Test @TestMetadata("handleException.kt") public void testHandleException() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/handleException.kt"); } + @Test @TestMetadata("ifExpressionInsideCoroutine_1_3.kt") public void testIfExpressionInsideCoroutine_1_3() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/ifExpressionInsideCoroutine_1_3.kt"); } + @Test @TestMetadata("inline.kt") public void testInline() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/inline.kt"); } + @Test @TestMetadata("inlineTwoReceivers.kt") public void testInlineTwoReceivers() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/inlineTwoReceivers.kt"); } + @Test @TestMetadata("member.kt") public void testMember() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/member.kt"); } + @Test @TestMetadata("noinlineTwoReceivers.kt") public void testNoinlineTwoReceivers() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/noinlineTwoReceivers.kt"); } + @Test @TestMetadata("operators.kt") public void testOperators() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/operators.kt"); } + @Test @TestMetadata("privateFunctions.kt") public void testPrivateFunctions() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/privateFunctions.kt"); } + @Test @TestMetadata("privateInFile.kt") public void testPrivateInFile() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/privateInFile.kt"); } + @Test @TestMetadata("returnNoSuspend.kt") public void testReturnNoSuspend() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/returnNoSuspend.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/simple.kt"); } + @Test @TestMetadata("superCall.kt") public void testSuperCall() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/superCall.kt"); } + @Test @TestMetadata("superCallAbstractClass.kt") public void testSuperCallAbstractClass() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/superCallAbstractClass.kt"); } + @Test @TestMetadata("superCallInterface.kt") public void testSuperCallInterface() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/superCallInterface.kt"); } + @Test @TestMetadata("superCallOverload.kt") public void testSuperCallOverload() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/superCallOverload.kt"); } + @Test @TestMetadata("withVariables.kt") public void testWithVariables() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/withVariables.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SuspendFunctionTypeCall extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class SuspendFunctionTypeCall { + @Test public void testAllFilesPresentInSuspendFunctionTypeCall() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("localVal.kt") public void testLocalVal() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall/localVal.kt"); } + @Test @TestMetadata("manyParameters.kt") public void testManyParameters() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall/manyParameters.kt"); } + @Test @TestMetadata("manyParametersNoCapture.kt") public void testManyParametersNoCapture() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall/manyParametersNoCapture.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall/simple.kt"); } + @Test @TestMetadata("suspendModifier.kt") public void testSuspendModifier() throws Exception { runTest("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall/suspendModifier.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/tailCallOptimizations") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TailCallOptimizations extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class TailCallOptimizations { + @Test public void testAllFilesPresentInTailCallOptimizations() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("crossinline.kt") public void testCrossinline() throws Exception { runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/crossinline.kt"); } + @Test @TestMetadata("inlineWithoutStateMachine.kt") public void testInlineWithoutStateMachine() throws Exception { runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithoutStateMachine.kt"); } + @Test @TestMetadata("innerObjectRetransformation.kt") public void testInnerObjectRetransformation() throws Exception { runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/innerObjectRetransformation.kt"); } + @Test @TestMetadata("tryCatch.kt") public void testTryCatch() throws Exception { runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/tryCatch.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unit") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Unit extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Unit { + @Test public void testAllFilesPresentInUnit() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unit"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/tailOperations") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TailOperations extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class TailOperations { + @Test public void testAllFilesPresentInTailOperations() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailOperations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("suspendWithIf.kt") public void testSuspendWithIf() throws Exception { runTest("compiler/testData/codegen/box/coroutines/tailOperations/suspendWithIf.kt"); } + @Test @TestMetadata("suspendWithTryCatch.kt") public void testSuspendWithTryCatch() throws Exception { runTest("compiler/testData/codegen/box/coroutines/tailOperations/suspendWithTryCatch.kt"); } + @Test @TestMetadata("suspendWithWhen.kt") public void testSuspendWithWhen() throws Exception { runTest("compiler/testData/codegen/box/coroutines/tailOperations/suspendWithWhen.kt"); } + @Test @TestMetadata("tailInlining.kt") public void testTailInlining() throws Exception { runTest("compiler/testData/codegen/box/coroutines/tailOperations/tailInlining.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/unitTypeReturn") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class UnitTypeReturn extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class UnitTypeReturn { + @Test public void testAllFilesPresentInUnitTypeReturn() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/unitTypeReturn"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("coroutineNonLocalReturn.kt") public void testCoroutineNonLocalReturn() throws Exception { runTest("compiler/testData/codegen/box/coroutines/unitTypeReturn/coroutineNonLocalReturn.kt"); } + @Test @TestMetadata("coroutineReturn.kt") public void testCoroutineReturn() throws Exception { runTest("compiler/testData/codegen/box/coroutines/unitTypeReturn/coroutineReturn.kt"); } + @Test @TestMetadata("inlineUnitFunction.kt") public void testInlineUnitFunction() throws Exception { runTest("compiler/testData/codegen/box/coroutines/unitTypeReturn/inlineUnitFunction.kt"); } + @Test @TestMetadata("interfaceDelegation.kt") public void testInterfaceDelegation() throws Exception { runTest("compiler/testData/codegen/box/coroutines/unitTypeReturn/interfaceDelegation.kt"); } + @Test @TestMetadata("suspendNonLocalReturn.kt") public void testSuspendNonLocalReturn() throws Exception { runTest("compiler/testData/codegen/box/coroutines/unitTypeReturn/suspendNonLocalReturn.kt"); } + @Test @TestMetadata("suspendReturn.kt") public void testSuspendReturn() throws Exception { runTest("compiler/testData/codegen/box/coroutines/unitTypeReturn/suspendReturn.kt"); } + @Test @TestMetadata("unitSafeCall.kt") public void testUnitSafeCall() throws Exception { runTest("compiler/testData/codegen/box/coroutines/unitTypeReturn/unitSafeCall.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/varSpilling") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class VarSpilling extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class VarSpilling { + @Test public void testAllFilesPresentInVarSpilling() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/varSpilling"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("fakeInlinerVariables.kt") public void testFakeInlinerVariables() throws Exception { runTest("compiler/testData/codegen/box/coroutines/varSpilling/fakeInlinerVariables.kt"); } + @Test @TestMetadata("kt19475.kt") public void testKt19475() throws Exception { runTest("compiler/testData/codegen/box/coroutines/varSpilling/kt19475.kt"); } + @Test @TestMetadata("kt38925.kt") public void testKt38925() throws Exception { runTest("compiler/testData/codegen/box/coroutines/varSpilling/kt38925.kt"); } + @Test @TestMetadata("kt49834.kt") public void testKt49834() throws Exception { runTest("compiler/testData/codegen/box/coroutines/varSpilling/kt49834.kt"); } + @Test @TestMetadata("lvtWithInlineOnly.kt") public void testLvtWithInlineOnly() throws Exception { runTest("compiler/testData/codegen/box/coroutines/varSpilling/lvtWithInlineOnly.kt"); } + @Test @TestMetadata("nullSpilling.kt") public void testNullSpilling() throws Exception { runTest("compiler/testData/codegen/box/coroutines/varSpilling/nullSpilling.kt"); } + @Test @TestMetadata("refinedIntTypesAnalysis.kt") public void testRefinedIntTypesAnalysis() throws Exception { runTest("compiler/testData/codegen/box/coroutines/varSpilling/refinedIntTypesAnalysis.kt"); } + @Test @TestMetadata("safeCallElvis.kt") public void testSafeCallElvis() throws Exception { runTest("compiler/testData/codegen/box/coroutines/varSpilling/safeCallElvis.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/varSpilling/cleanup") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Cleanup extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Cleanup { + @Test public void testAllFilesPresentInCleanup() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/varSpilling/cleanup"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/coroutines/varSpilling/debugMode") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DebugMode extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DebugMode { + @Test public void testAllFilesPresentInDebugMode() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/varSpilling/debugMode"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @@ -8778,360 +9912,393 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/correctFrontendCode") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class CorrectFrontendCode extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class CorrectFrontendCode { + @Test public void testAllFilesPresentInCorrectFrontendCode() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/correctFrontendCode"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("privateNestedClassInSuper.kt") public void testPrivateNestedClassInSuper() throws Exception { runTest("compiler/testData/codegen/box/correctFrontendCode/privateNestedClassInSuper.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/dataClasses") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DataClasses extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DataClasses { + @Test public void testAllFilesPresentInDataClasses() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("arrayParams.kt") public void testArrayParams() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/arrayParams.kt"); } + @Test @TestMetadata("changingVarParam.kt") public void testChangingVarParam() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/changingVarParam.kt"); } + @Test @TestMetadata("dataClassWithManyFields.kt") public void testDataClassWithManyFields() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/dataClassWithManyFields.kt"); } + @Test @TestMetadata("doubleParam.kt") public void testDoubleParam() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/doubleParam.kt"); } + @Test @TestMetadata("equalityChecksPrimitiveUnboxed.kt") public void testEqualityChecksPrimitiveUnboxed() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/equalityChecksPrimitiveUnboxed.kt"); } + @Test @TestMetadata("floatParam.kt") public void testFloatParam() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/floatParam.kt"); } + @Test @TestMetadata("fromOtherModule.kt") public void testFromOtherModule() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/fromOtherModule.kt"); } + @Test @TestMetadata("genericParam.kt") public void testGenericParam() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/genericParam.kt"); } + @Test @TestMetadata("kt49715.kt") public void testKt49715() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/kt49715.kt"); } + @Test @TestMetadata("kt49715_behaviorChange.kt") public void testKt49715_behaviorChange() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/kt49715_behaviorChange.kt"); } + @Test @TestMetadata("mixedParams.kt") public void testMixedParams() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/mixedParams.kt"); } + @Test @TestMetadata("multiDeclaration.kt") public void testMultiDeclaration() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/multiDeclaration.kt"); } + @Test @TestMetadata("multiDeclarationFor.kt") public void testMultiDeclarationFor() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/multiDeclarationFor.kt"); } + @Test @TestMetadata("nonTrivialFinalMemberInSuperClass.kt") public void testNonTrivialFinalMemberInSuperClass() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/nonTrivialFinalMemberInSuperClass.kt"); } + @Test @TestMetadata("nonTrivialMemberInSuperClass.kt") public void testNonTrivialMemberInSuperClass() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/nonTrivialMemberInSuperClass.kt"); } + @Test @TestMetadata("privateValParams.kt") public void testPrivateValParams() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/privateValParams.kt"); } + @Test @TestMetadata("twoValParams.kt") public void testTwoValParams() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/twoValParams.kt"); } + @Test @TestMetadata("twoVarParams.kt") public void testTwoVarParams() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/twoVarParams.kt"); } + @Test @TestMetadata("unitComponent.kt") public void testUnitComponent() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/unitComponent.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/dataClasses/components") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Components extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Components { + @Test public void testAllFilesPresentInComponents() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/components"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt49812.kt") public void testKt49812() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/components/kt49812.kt"); } + @Test @TestMetadata("kt49936.kt") public void testKt49936() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/components/kt49936.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/dataClasses/copy") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Copy extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Copy { + @Test public void testAllFilesPresentInCopy() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/copy"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("constructorWithDefaultParam.kt") public void testConstructorWithDefaultParam() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/copy/constructorWithDefaultParam.kt"); } + @Test @TestMetadata("copyInObjectNestedDataClass.kt") public void testCopyInObjectNestedDataClass() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/copy/copyInObjectNestedDataClass.kt"); } + @Test @TestMetadata("kt12708.kt") public void testKt12708() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/copy/kt12708.kt"); } + @Test @TestMetadata("kt3033.kt") public void testKt3033() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/copy/kt3033.kt"); } + @Test @TestMetadata("valInConstructorParams.kt") public void testValInConstructorParams() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/copy/valInConstructorParams.kt"); } + @Test @TestMetadata("varInConstructorParams.kt") public void testVarInConstructorParams() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/copy/varInConstructorParams.kt"); } + @Test @TestMetadata("withGenericParameter.kt") public void testWithGenericParameter() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/copy/withGenericParameter.kt"); } + @Test @TestMetadata("withSecondaryConstructor.kt") public void testWithSecondaryConstructor() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/copy/withSecondaryConstructor.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/dataClasses/equals") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Equals extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Equals { + @Test public void testAllFilesPresentInEquals() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/equals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("alreadyDeclared.kt") public void testAlreadyDeclared() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/equals/alreadyDeclared.kt"); } + @Test @TestMetadata("genericarray.kt") public void testGenericarray() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/equals/genericarray.kt"); } + @Test @TestMetadata("intarray.kt") public void testIntarray() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/equals/intarray.kt"); } + @Test @TestMetadata("null.kt") public void testNull() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/equals/null.kt"); } + @Test @TestMetadata("nullother.kt") public void testNullother() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/equals/nullother.kt"); } + @Test @TestMetadata("sameinstance.kt") public void testSameinstance() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/equals/sameinstance.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/dataClasses/hashCode") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class HashCode extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class HashCode { + @Test public void testAllFilesPresentInHashCode() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/hashCode"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("alreadyDeclared.kt") public void testAlreadyDeclared() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/hashCode/alreadyDeclared.kt"); } + @Test @TestMetadata("boolean.kt") public void testBoolean() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/hashCode/boolean.kt"); } + @Test @TestMetadata("byte.kt") public void testByte() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/hashCode/byte.kt"); } + @Test @TestMetadata("char.kt") public void testChar() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/hashCode/char.kt"); } + @Test @TestMetadata("double.kt") public void testDouble() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/hashCode/double.kt"); } + @Test @TestMetadata("float.kt") public void testFloat() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/hashCode/float.kt"); } + @Test @TestMetadata("genericNull.kt") public void testGenericNull() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/hashCode/genericNull.kt"); } + @Test @TestMetadata("int.kt") public void testInt() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/hashCode/int.kt"); } + @Test @TestMetadata("long.kt") public void testLong() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/hashCode/long.kt"); } + @Test @TestMetadata("null.kt") public void testNull() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/hashCode/null.kt"); } + @Test @TestMetadata("short.kt") public void testShort() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/hashCode/short.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/dataClasses/toString") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ToString extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ToString { + @Test public void testAllFilesPresentInToString() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/toString"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("alreadyDeclared.kt") public void testAlreadyDeclared() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/toString/alreadyDeclared.kt"); } + @Test @TestMetadata("arrayParams.kt") public void testArrayParams() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/toString/arrayParams.kt"); } + @Test @TestMetadata("changingVarParam.kt") public void testChangingVarParam() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/toString/changingVarParam.kt"); } + @Test @TestMetadata("genericParam.kt") public void testGenericParam() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/toString/genericParam.kt"); } + @Test @TestMetadata("mixedParams.kt") public void testMixedParams() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/toString/mixedParams.kt"); } + @Test @TestMetadata("primitiveArrays.kt") public void testPrimitiveArrays() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/toString/primitiveArrays.kt"); } + @Test @TestMetadata("unitComponent.kt") public void testUnitComponent() throws Exception { runTest("compiler/testData/codegen/box/dataClasses/toString/unitComponent.kt"); @@ -9139,538 +10306,601 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/dataObjects") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DataObjects extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DataObjects { + @Test public void testAllFilesPresentInDataObjects() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataObjects"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("equals.kt") public void testEquals() throws Exception { runTest("compiler/testData/codegen/box/dataObjects/equals.kt"); } + @Test @TestMetadata("hashCode.kt") public void testHashCode() throws Exception { runTest("compiler/testData/codegen/box/dataObjects/hashCode.kt"); } + @Test @TestMetadata("toString.kt") public void testToString() throws Exception { runTest("compiler/testData/codegen/box/dataObjects/toString.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/deadCodeElimination") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DeadCodeElimination extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DeadCodeElimination { + @Test public void testAllFilesPresentInDeadCodeElimination() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/deadCodeElimination"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("emptyVariableRange.kt") public void testEmptyVariableRange() throws Exception { runTest("compiler/testData/codegen/box/deadCodeElimination/emptyVariableRange.kt"); } + @Test @TestMetadata("intersectingVariableRange.kt") public void testIntersectingVariableRange() throws Exception { runTest("compiler/testData/codegen/box/deadCodeElimination/intersectingVariableRange.kt"); } + @Test @TestMetadata("intersectingVariableRangeInFinally.kt") public void testIntersectingVariableRangeInFinally() throws Exception { runTest("compiler/testData/codegen/box/deadCodeElimination/intersectingVariableRangeInFinally.kt"); } + @Test @TestMetadata("kt14357.kt") public void testKt14357() throws Exception { runTest("compiler/testData/codegen/box/deadCodeElimination/kt14357.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/defaultArguments") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DefaultArguments extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DefaultArguments { + @Test public void testAllFilesPresentInDefaultArguments() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("callDefaultFromInitializer.kt") public void testCallDefaultFromInitializer() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/callDefaultFromInitializer.kt"); } + @Test @TestMetadata("captureInTailrec.kt") public void testCaptureInTailrec() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/captureInTailrec.kt"); } + @Test @TestMetadata("complexInheritance.kt") public void testComplexInheritance() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/complexInheritance.kt"); } + @Test @TestMetadata("implementedByFake.kt") public void testImplementedByFake() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/implementedByFake.kt"); } + @Test @TestMetadata("implementedByFake2.kt") public void testImplementedByFake2() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/implementedByFake2.kt"); } + @Test @TestMetadata("implementedByFake3.kt") public void testImplementedByFake3() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/implementedByFake3.kt"); } + @Test @TestMetadata("inheritedFromInterfaceViaAbstractSuperclass.kt") public void testInheritedFromInterfaceViaAbstractSuperclass() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/inheritedFromInterfaceViaAbstractSuperclass.kt"); } + @Test @TestMetadata("kt36853.kt") public void testKt36853() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/kt36853.kt"); } + @Test @TestMetadata("kt36853_fibonacci.kt") public void testKt36853_fibonacci() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/kt36853_fibonacci.kt"); } + @Test @TestMetadata("kt36853_nestedObject.kt") public void testKt36853_nestedObject() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/kt36853_nestedObject.kt"); } + @Test @TestMetadata("kt36853a.kt") public void testKt36853a() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/kt36853a.kt"); } + @Test @TestMetadata("kt46189.kt") public void testKt46189() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/kt46189.kt"); } + @Test @TestMetadata("kt47073.kt") public void testKt47073() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/kt47073.kt"); } + @Test @TestMetadata("kt47073_nested.kt") public void testKt47073_nested() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/kt47073_nested.kt"); } + @Test @TestMetadata("kt48391.kt") public void testKt48391() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/kt48391.kt"); } + @Test @TestMetadata("kt52702.kt") public void testKt52702() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/kt52702.kt"); } + @Test @TestMetadata("kt6382.kt") public void testKt6382() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/kt6382.kt"); } + @Test @TestMetadata("protected.kt") public void testProtected() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/protected.kt"); } + @Test @TestMetadata("recursiveDefaultArguments.kt") public void testRecursiveDefaultArguments() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/recursiveDefaultArguments.kt"); } + @Test @TestMetadata("referenceAsArg.kt") public void testReferenceAsArg() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/referenceAsArg.kt"); } + @Test @TestMetadata("simpleFromOtherFile.kt") public void testSimpleFromOtherFile() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/simpleFromOtherFile.kt"); } + @Test @TestMetadata("useNextParamInLambda.kt") public void testUseNextParamInLambda() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/useNextParamInLambda.kt"); } + @Test @TestMetadata("useNextParamInLambdaTailrec.kt") public void testUseNextParamInLambdaTailrec() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/useNextParamInLambdaTailrec.kt"); } + @Test @TestMetadata("useThisInLambda.kt") public void testUseThisInLambda() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/useThisInLambda.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/defaultArguments/constructor") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Constructor extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Constructor { + @Test public void testAllFilesPresentInConstructor() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/constructor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("annotation.kt") public void testAnnotation() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/constructor/annotation.kt"); } + @Test @TestMetadata("annotationWithEmptyArray.kt") public void testAnnotationWithEmptyArray() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/constructor/annotationWithEmptyArray.kt"); } + @Test @TestMetadata("defArgs1.kt") public void testDefArgs1() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/constructor/defArgs1.kt"); } + @Test @TestMetadata("defArgs1InnerClass.kt") public void testDefArgs1InnerClass() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/constructor/defArgs1InnerClass.kt"); } + @Test @TestMetadata("defArgs2.kt") public void testDefArgs2() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/constructor/defArgs2.kt"); } + @Test @TestMetadata("doubleDefArgs1InnerClass.kt") public void testDoubleDefArgs1InnerClass() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/constructor/doubleDefArgs1InnerClass.kt"); } + @Test @TestMetadata("enum.kt") public void testEnum() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/constructor/enum.kt"); } + @Test @TestMetadata("enumWithOneDefArg.kt") public void testEnumWithOneDefArg() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/constructor/enumWithOneDefArg.kt"); } + @Test @TestMetadata("enumWithTwoDefArgs.kt") public void testEnumWithTwoDefArgs() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/constructor/enumWithTwoDefArgs.kt"); } + @Test @TestMetadata("enumWithTwoDoubleDefArgs.kt") public void testEnumWithTwoDoubleDefArgs() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/constructor/enumWithTwoDoubleDefArgs.kt"); } + @Test @TestMetadata("innerClass32Args.kt") public void testInnerClass32Args() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/constructor/innerClass32Args.kt"); } + @Test @TestMetadata("kt2852.kt") public void testKt2852() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/constructor/kt2852.kt"); } + @Test @TestMetadata("kt30517.kt") public void testKt30517() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/constructor/kt30517.kt"); } + @Test @TestMetadata("kt3060.kt") public void testKt3060() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/constructor/kt3060.kt"); } + @Test @TestMetadata("objectExpressionDelegatingToSecondaryConstructor.kt") public void testObjectExpressionDelegatingToSecondaryConstructor() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/constructor/objectExpressionDelegatingToSecondaryConstructor.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/defaultArguments/convention") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Convention extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Convention { + @Test public void testAllFilesPresentInConvention() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/convention"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("incWithDefaultInGetter.kt") public void testIncWithDefaultInGetter() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/convention/incWithDefaultInGetter.kt"); } + @Test @TestMetadata("incWithDefaults.kt") public void testIncWithDefaults() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/convention/incWithDefaults.kt"); } + @Test @TestMetadata("kt16520.kt") public void testKt16520() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/convention/kt16520.kt"); } + @Test @TestMetadata("kt9140.kt") public void testKt9140() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/convention/kt9140.kt"); } + @Test @TestMetadata("plusAssignWithDefaultInGetter.kt") public void testPlusAssignWithDefaultInGetter() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/convention/plusAssignWithDefaultInGetter.kt"); } + @Test @TestMetadata("plusAssignWithDefaults.kt") public void testPlusAssignWithDefaults() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/convention/plusAssignWithDefaults.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/defaultArguments/function") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Function extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Function { + @Test @TestMetadata("abstractClass.kt") public void testAbstractClass() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/abstractClass.kt"); } + @Test public void testAllFilesPresentInFunction() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/function"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("complexInheritance.kt") public void testComplexInheritance() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/complexInheritance.kt"); } + @Test @TestMetadata("covariantOverride.kt") public void testCovariantOverride() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/covariantOverride.kt"); } + @Test @TestMetadata("covariantOverrideGeneric.kt") public void testCovariantOverrideGeneric() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/covariantOverrideGeneric.kt"); } + @Test @TestMetadata("defaultLambdaInline.kt") public void testDefaultLambdaInline() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/defaultLambdaInline.kt"); } + @Test @TestMetadata("extensionFunctionManyArgs.kt") public void testExtensionFunctionManyArgs() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/extensionFunctionManyArgs.kt"); } + @Test @TestMetadata("extentionFunction.kt") public void testExtentionFunction() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/extentionFunction.kt"); } + @Test @TestMetadata("extentionFunctionDouble.kt") public void testExtentionFunctionDouble() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/extentionFunctionDouble.kt"); } + @Test @TestMetadata("extentionFunctionDoubleTwoArgs.kt") public void testExtentionFunctionDoubleTwoArgs() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/extentionFunctionDoubleTwoArgs.kt"); } + @Test @TestMetadata("extentionFunctionInClassObject.kt") public void testExtentionFunctionInClassObject() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/extentionFunctionInClassObject.kt"); } + @Test @TestMetadata("extentionFunctionInObject.kt") public void testExtentionFunctionInObject() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/extentionFunctionInObject.kt"); } + @Test @TestMetadata("extentionFunctionWithOneDefArg.kt") public void testExtentionFunctionWithOneDefArg() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/extentionFunctionWithOneDefArg.kt"); } + @Test @TestMetadata("funInTrait.kt") public void testFunInTrait() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/funInTrait.kt"); } + @Test @TestMetadata("funInTraitChain.kt") public void testFunInTraitChain() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/funInTraitChain.kt"); } + @Test @TestMetadata("innerExtentionFunction.kt") public void testInnerExtentionFunction() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/innerExtentionFunction.kt"); } + @Test @TestMetadata("innerExtentionFunctionDouble.kt") public void testInnerExtentionFunctionDouble() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/innerExtentionFunctionDouble.kt"); } + @Test @TestMetadata("innerExtentionFunctionDoubleTwoArgs.kt") public void testInnerExtentionFunctionDoubleTwoArgs() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/innerExtentionFunctionDoubleTwoArgs.kt"); } + @Test @TestMetadata("innerExtentionFunctionManyArgs.kt") public void testInnerExtentionFunctionManyArgs() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/innerExtentionFunctionManyArgs.kt"); } + @Test @TestMetadata("kt15971.kt") public void testKt15971() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/kt15971.kt"); } + @Test @TestMetadata("kt15971_2.kt") public void testKt15971_2() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/kt15971_2.kt"); } + @Test @TestMetadata("kt15971_3.kt") public void testKt15971_3() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/kt15971_3.kt"); } + @Test @TestMetadata("kt36188.kt") public void testKt36188() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/kt36188.kt"); } + @Test @TestMetadata("kt36188_2.kt") public void testKt36188_2() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/kt36188_2.kt"); } + @Test @TestMetadata("kt5232.kt") public void testKt5232() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/kt5232.kt"); } + @Test @TestMetadata("memberFunctionManyArgs.kt") public void testMemberFunctionManyArgs() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/memberFunctionManyArgs.kt"); } + @Test @TestMetadata("mixingNamedAndPositioned.kt") public void testMixingNamedAndPositioned() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/mixingNamedAndPositioned.kt"); } + @Test @TestMetadata("topLevelManyArgs.kt") public void testTopLevelManyArgs() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/topLevelManyArgs.kt"); } + @Test @TestMetadata("trait.kt") public void testTrait() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/function/trait.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/defaultArguments/private") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Private extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Private { + @Test public void testAllFilesPresentInPrivate() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/private"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("memberExtensionFunction.kt") public void testMemberExtensionFunction() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/private/memberExtensionFunction.kt"); } + @Test @TestMetadata("memberFunction.kt") public void testMemberFunction() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/private/memberFunction.kt"); } + @Test @TestMetadata("primaryConstructor.kt") public void testPrimaryConstructor() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/private/primaryConstructor.kt"); } + @Test @TestMetadata("secondaryConstructor.kt") public void testSecondaryConstructor() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/private/secondaryConstructor.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/defaultArguments/signature") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Signature extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Signature { + @Test public void testAllFilesPresentInSignature() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/signature"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt2789.kt") public void testKt2789() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/signature/kt2789.kt"); } + @Test @TestMetadata("kt9428.kt") public void testKt9428() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/signature/kt9428.kt"); } + @Test @TestMetadata("kt9924.kt") public void testKt9924() throws Exception { runTest("compiler/testData/codegen/box/defaultArguments/signature/kt9924.kt"); @@ -9678,746 +10908,845 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/delegatedProperty") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DelegatedProperty extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DelegatedProperty { + @Test @TestMetadata("accessTopLevelDelegatedPropertyInClinit.kt") public void testAccessTopLevelDelegatedPropertyInClinit() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/accessTopLevelDelegatedPropertyInClinit.kt"); } + @Test public void testAllFilesPresentInDelegatedProperty() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("beforeDeclarationContainerOptimization.kt") public void testBeforeDeclarationContainerOptimization() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/beforeDeclarationContainerOptimization.kt"); } + @Test @TestMetadata("capturePropertyInClosure.kt") public void testCapturePropertyInClosure() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/capturePropertyInClosure.kt"); } + @Test @TestMetadata("castGetReturnType.kt") public void testCastGetReturnType() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/castGetReturnType.kt"); } + @Test @TestMetadata("castSetParameter.kt") public void testCastSetParameter() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/castSetParameter.kt"); } + @Test @TestMetadata("delegateAsInnerClass.kt") public void testDelegateAsInnerClass() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateAsInnerClass.kt"); } + @Test @TestMetadata("delegateByOtherProperty.kt") public void testDelegateByOtherProperty() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateByOtherProperty.kt"); } + @Test @TestMetadata("delegateByTopLevelFun.kt") public void testDelegateByTopLevelFun() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateByTopLevelFun.kt"); } + @Test @TestMetadata("delegateByTopLevelProperty.kt") public void testDelegateByTopLevelProperty() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateByTopLevelProperty.kt"); } + @Test @TestMetadata("delegateForExtProperty.kt") public void testDelegateForExtProperty() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateForExtProperty.kt"); } + @Test @TestMetadata("delegateForExtPropertyInClass.kt") public void testDelegateForExtPropertyInClass() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateForExtPropertyInClass.kt"); } + @Test @TestMetadata("delegateToConstructorParameter.kt") public void testDelegateToConstructorParameter() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToConstructorParameter.kt"); } + @Test @TestMetadata("delegateWithPrivateSet.kt") public void testDelegateWithPrivateSet() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateWithPrivateSet.kt"); } + @Test @TestMetadata("delegatedPropertyInEnum.kt") public void testDelegatedPropertyInEnum() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegatedPropertyInEnum.kt"); } + @Test @TestMetadata("extensionDelegatesWithSameNames.kt") public void testExtensionDelegatesWithSameNames() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/extensionDelegatesWithSameNames.kt"); } + @Test @TestMetadata("extensionPropertyAndExtensionGetValue.kt") public void testExtensionPropertyAndExtensionGetValue() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/extensionPropertyAndExtensionGetValue.kt"); } + @Test @TestMetadata("functionRefDelefate.kt") public void testFunctionRefDelefate() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/functionRefDelefate.kt"); } + @Test @TestMetadata("genericDelegate.kt") public void testGenericDelegate() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/genericDelegate.kt"); } + @Test @TestMetadata("genericDelegateUncheckedCast1.kt") public void testGenericDelegateUncheckedCast1() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/genericDelegateUncheckedCast1.kt"); } + @Test @TestMetadata("genericDelegateUncheckedCast2.kt") public void testGenericDelegateUncheckedCast2() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/genericDelegateUncheckedCast2.kt"); } + @Test @TestMetadata("genericSetValueViaSyntheticAccessor.kt") public void testGenericSetValueViaSyntheticAccessor() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/genericSetValueViaSyntheticAccessor.kt"); } + @Test @TestMetadata("getAsExtensionFun.kt") public void testGetAsExtensionFun() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/getAsExtensionFun.kt"); } + @Test @TestMetadata("getAsExtensionFunInClass.kt") public void testGetAsExtensionFunInClass() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/getAsExtensionFunInClass.kt"); } + @Test @TestMetadata("inClassVal.kt") public void testInClassVal() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/inClassVal.kt"); } + @Test @TestMetadata("inClassVar.kt") public void testInClassVar() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/inClassVar.kt"); } + @Test @TestMetadata("inTrait.kt") public void testInTrait() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/inTrait.kt"); } + @Test @TestMetadata("inferredPropertyType.kt") public void testInferredPropertyType() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/inferredPropertyType.kt"); } + @Test @TestMetadata("insideInlinedObjectMultiModule.kt") public void testInsideInlinedObjectMultiModule() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/insideInlinedObjectMultiModule.kt"); } + @Test @TestMetadata("kt35707.kt") public void testKt35707() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/kt35707.kt"); } + @Test @TestMetadata("kt37204.kt") public void testKt37204() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/kt37204.kt"); } + @Test @TestMetadata("kt4138.kt") public void testKt4138() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/kt4138.kt"); } + @Test @TestMetadata("kt45431.kt") public void testKt45431() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/kt45431.kt"); } + @Test @TestMetadata("kt6722.kt") public void testKt6722() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/kt6722.kt"); } + @Test @TestMetadata("kt9712.kt") public void testKt9712() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/kt9712.kt"); } + @Test @TestMetadata("privateVar.kt") public void testPrivateVar() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/privateVar.kt"); } + @Test @TestMetadata("protectedVarWithPrivateSet.kt") public void testProtectedVarWithPrivateSet() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/protectedVarWithPrivateSet.kt"); } + @Test @TestMetadata("referenceEnclosingClassFieldInReceiver.kt") public void testReferenceEnclosingClassFieldInReceiver() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/referenceEnclosingClassFieldInReceiver.kt"); } + @Test @TestMetadata("referenceEnclosingClassFieldInReceiver2.kt") public void testReferenceEnclosingClassFieldInReceiver2() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/referenceEnclosingClassFieldInReceiver2.kt"); } + @Test @TestMetadata("setAsExtensionFun.kt") public void testSetAsExtensionFun() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/setAsExtensionFun.kt"); } + @Test @TestMetadata("setAsExtensionFunInClass.kt") public void testSetAsExtensionFunInClass() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/setAsExtensionFunInClass.kt"); } + @Test @TestMetadata("topLevelVal.kt") public void testTopLevelVal() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/topLevelVal.kt"); } + @Test @TestMetadata("topLevelVar.kt") public void testTopLevelVar() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/topLevelVar.kt"); } + @Test @TestMetadata("twoPropByOneDelegete.kt") public void testTwoPropByOneDelegete() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/twoPropByOneDelegete.kt"); } + @Test @TestMetadata("useKPropertyLater.kt") public void testUseKPropertyLater() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/useKPropertyLater.kt"); } + @Test @TestMetadata("valByMapDelegatedProperty.kt") public void testValByMapDelegatedProperty() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/valByMapDelegatedProperty.kt"); } + @Test @TestMetadata("valInInnerClass.kt") public void testValInInnerClass() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/valInInnerClass.kt"); } + @Test @TestMetadata("varInInnerClass.kt") public void testVarInInnerClass() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/varInInnerClass.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/delegatedProperty/delegateToAnother") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DelegateToAnother extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DelegateToAnother { + @Test public void testAllFilesPresentInDelegateToAnother() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/delegateToAnother"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("custom.kt") public void testCustom() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToAnother/custom.kt"); } + @Test @TestMetadata("kt49793_companionObject.kt") public void testKt49793_companionObject() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToAnother/kt49793_companionObject.kt"); } + @Test @TestMetadata("kt49793_interfaceCompanionObject.kt") public void testKt49793_interfaceCompanionObject() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToAnother/kt49793_interfaceCompanionObject.kt"); } + @Test @TestMetadata("kt49793_object.kt") public void testKt49793_object() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToAnother/kt49793_object.kt"); } + @Test @TestMetadata("kt50019_noOptimizedCallableReferences.kt") public void testKt50019_noOptimizedCallableReferences() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToAnother/kt50019_noOptimizedCallableReferences.kt"); } + @Test @TestMetadata("mutable.kt") public void testMutable() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToAnother/mutable.kt"); } + @Test @TestMetadata("openProperty.kt") public void testOpenProperty() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToAnother/openProperty.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToAnother/simple.kt"); } + @Test @TestMetadata("withSideEffects.kt") public void testWithSideEffects() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToAnother/withSideEffects.kt"); } + @Test @TestMetadata("withSideEffectsFromFileClass.kt") public void testWithSideEffectsFromFileClass() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToAnother/withSideEffectsFromFileClass.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/delegatedProperty/delegateToConst") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DelegateToConst extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DelegateToConst { + @Test public void testAllFilesPresentInDelegateToConst() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/delegateToConst"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("delegateToConst.kt") public void testDelegateToConst() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToConst/delegateToConst.kt"); } + @Test @TestMetadata("delegateToConstProperty.kt") public void testDelegateToConstProperty() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToConst/delegateToConstProperty.kt"); } + @Test @TestMetadata("delegateToNull.kt") public void testDelegateToNull() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToConst/delegateToNull.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/delegatedProperty/delegateToFinalProperty") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DelegateToFinalProperty extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DelegateToFinalProperty { + @Test public void testAllFilesPresentInDelegateToFinalProperty() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/delegateToFinalProperty"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("chain.kt") public void testChain() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToFinalProperty/chain.kt"); } + @Test @TestMetadata("delegateToFinalInstanceProperty.kt") public void testDelegateToFinalInstanceProperty() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToFinalProperty/delegateToFinalInstanceProperty.kt"); } + @Test @TestMetadata("delegateToFinalObjectProperty.kt") public void testDelegateToFinalObjectProperty() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToFinalProperty/delegateToFinalObjectProperty.kt"); } + @Test @TestMetadata("delegateToFinalProperty.kt") public void testDelegateToFinalProperty() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToFinalProperty/delegateToFinalProperty.kt"); } + @Test @TestMetadata("finalPropertyInAnotherFile.kt") public void testFinalPropertyInAnotherFile() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToFinalProperty/finalPropertyInAnotherFile.kt"); } + @Test @TestMetadata("initializeContainerOfTopLevelProperties.kt") public void testInitializeContainerOfTopLevelProperties() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToFinalProperty/initializeContainerOfTopLevelProperties.kt"); } + @Test @TestMetadata("memberExtensionPropertyAndImportFromObject.kt") public void testMemberExtensionPropertyAndImportFromObject() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToFinalProperty/memberExtensionPropertyAndImportFromObject.kt"); } + @Test @TestMetadata("memberExtensionPropertyAndLocalDelegatedProperty.kt") public void testMemberExtensionPropertyAndLocalDelegatedProperty() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToFinalProperty/memberExtensionPropertyAndLocalDelegatedProperty.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/delegatedProperty/delegateToSingleton") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DelegateToSingleton extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DelegateToSingleton { + @Test public void testAllFilesPresentInDelegateToSingleton() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/delegateToSingleton"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("delegateToEnum.kt") public void testDelegateToEnum() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToSingleton/delegateToEnum.kt"); } + @Test @TestMetadata("delegateToEnumInAClass.kt") public void testDelegateToEnumInAClass() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToSingleton/delegateToEnumInAClass.kt"); } + @Test @TestMetadata("delegateToSingleton.kt") public void testDelegateToSingleton() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToSingleton/delegateToSingleton.kt"); } + @Test @TestMetadata("noInitializationOfOuterClass.kt") public void testNoInitializationOfOuterClass() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToSingleton/noInitializationOfOuterClass.kt"); } + @Test @TestMetadata("withSideEffects.kt") public void testWithSideEffects() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToSingleton/withSideEffects.kt"); } + @Test @TestMetadata("withSideEffectsFromFileClass.kt") public void testWithSideEffectsFromFileClass() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToSingleton/withSideEffectsFromFileClass.kt"); } + @Test @TestMetadata("withSideEffectsToEnum.kt") public void testWithSideEffectsToEnum() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToSingleton/withSideEffectsToEnum.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/delegatedProperty/delegateToThis") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DelegateToThis extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DelegateToThis { + @Test public void testAllFilesPresentInDelegateToThis() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/delegateToThis"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("delegateToOuterThis.kt") public void testDelegateToOuterThis() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToThis/delegateToOuterThis.kt"); } + @Test @TestMetadata("delegateToThis.kt") public void testDelegateToThis() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToThis/delegateToThis.kt"); } + @Test @TestMetadata("delegateToThisByExtension.kt") public void testDelegateToThisByExtension() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/delegateToThis/delegateToThisByExtension.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/delegatedProperty/local") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Local extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Local { + @Test public void testAllFilesPresentInLocal() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/local"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("capturedLocalVal.kt") public void testCapturedLocalVal() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/local/capturedLocalVal.kt"); } + @Test @TestMetadata("capturedLocalValNoInline.kt") public void testCapturedLocalValNoInline() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/local/capturedLocalValNoInline.kt"); } + @Test @TestMetadata("capturedLocalVar.kt") public void testCapturedLocalVar() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/local/capturedLocalVar.kt"); } + @Test @TestMetadata("capturedLocalVarNoInline.kt") public void testCapturedLocalVarNoInline() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/local/capturedLocalVarNoInline.kt"); } + @Test @TestMetadata("inlineGetValue.kt") public void testInlineGetValue() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/local/inlineGetValue.kt"); } + @Test @TestMetadata("inlineOperators.kt") public void testInlineOperators() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/local/inlineOperators.kt"); } + @Test @TestMetadata("kt12891.kt") public void testKt12891() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/local/kt12891.kt"); } + @Test @TestMetadata("kt13557.kt") public void testKt13557() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/local/kt13557.kt"); } + @Test @TestMetadata("kt16864.kt") public void testKt16864() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/local/kt16864.kt"); } + @Test @TestMetadata("kt19690.kt") public void testKt19690() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/local/kt19690.kt"); } + @Test @TestMetadata("kt21085.kt") public void testKt21085() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/local/kt21085.kt"); } + @Test @TestMetadata("kt23117.kt") public void testKt23117() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/local/kt23117.kt"); } + @Test @TestMetadata("localVal.kt") public void testLocalVal() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/local/localVal.kt"); } + @Test @TestMetadata("localValNoExplicitType.kt") public void testLocalValNoExplicitType() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/local/localValNoExplicitType.kt"); } + @Test @TestMetadata("localVar.kt") public void testLocalVar() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/local/localVar.kt"); } + @Test @TestMetadata("localVarNoExplicitType.kt") public void testLocalVarNoExplicitType() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/local/localVarNoExplicitType.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class OptimizedDelegatedProperties extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class OptimizedDelegatedProperties { + @Test public void testAllFilesPresentInOptimizedDelegatedProperties() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("definedInSources.kt") public void testDefinedInSources() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties/definedInSources.kt"); } + @Test @TestMetadata("definedInSourcesWithNonNullParameter.kt") public void testDefinedInSourcesWithNonNullParameter() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties/definedInSourcesWithNonNullParameter.kt"); } + @Test @TestMetadata("inSeparateModule.kt") public void testInSeparateModule() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties/inSeparateModule.kt"); } + @Test @TestMetadata("inSeparateModuleWithNonNullParameter.kt") public void testInSeparateModuleWithNonNullParameter() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties/inSeparateModuleWithNonNullParameter.kt"); } + @Test @TestMetadata("kt40815.kt") public void testKt40815() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties/kt40815.kt"); } + @Test @TestMetadata("kt40815_2.kt") public void testKt40815_2() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties/kt40815_2.kt"); } + @Test @TestMetadata("kt40815_3.kt") public void testKt40815_3() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties/kt40815_3.kt"); } + @Test @TestMetadata("kt42253.kt") public void testKt42253() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties/kt42253.kt"); } + @Test @TestMetadata("kt48825.kt") public void testKt48825() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties/kt48825.kt"); } + @Test @TestMetadata("lazy.kt") public void testLazy() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties/lazy.kt"); } + @Test @TestMetadata("mixedArgumentSizes.kt") public void testMixedArgumentSizes() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties/mixedArgumentSizes.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/delegatedProperty/provideDelegate") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ProvideDelegate extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ProvideDelegate { + @Test public void testAllFilesPresentInProvideDelegate() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/provideDelegate"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("delegatedPropertyWithIdProvideDelegate.kt") public void testDelegatedPropertyWithIdProvideDelegate() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/delegatedPropertyWithIdProvideDelegate.kt"); } + @Test @TestMetadata("differentReceivers.kt") public void testDifferentReceivers() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/differentReceivers.kt"); } + @Test @TestMetadata("evaluationOrder.kt") public void testEvaluationOrder() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/evaluationOrder.kt"); } + @Test @TestMetadata("evaluationOrderVar.kt") public void testEvaluationOrderVar() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/evaluationOrderVar.kt"); } + @Test @TestMetadata("extensionDelegated.kt") public void testExtensionDelegated() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/extensionDelegated.kt"); } + @Test @TestMetadata("generic.kt") public void testGeneric() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/generic.kt"); } + @Test @TestMetadata("genericDelegateWithNoAdditionalInfo.kt") public void testGenericDelegateWithNoAdditionalInfo() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/genericDelegateWithNoAdditionalInfo.kt"); } + @Test @TestMetadata("genericProvideDelegateOnNumberLiteral.kt") public void testGenericProvideDelegateOnNumberLiteral() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/genericProvideDelegateOnNumberLiteral.kt"); } + @Test @TestMetadata("hostCheck.kt") public void testHostCheck() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/hostCheck.kt"); } + @Test @TestMetadata("inClass.kt") public void testInClass() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/inClass.kt"); } + @Test @TestMetadata("inlineProvideDelegate.kt") public void testInlineProvideDelegate() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/inlineProvideDelegate.kt"); } + @Test @TestMetadata("kt15437.kt") public void testKt15437() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/kt15437.kt"); } + @Test @TestMetadata("kt16441.kt") public void testKt16441() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/kt16441.kt"); } + @Test @TestMetadata("kt18902.kt") public void testKt18902() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/kt18902.kt"); } + @Test @TestMetadata("kt39588.kt") public void testKt39588() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/kt39588.kt"); } + @Test @TestMetadata("local.kt") public void testLocal() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/local.kt"); } + @Test @TestMetadata("localCaptured.kt") public void testLocalCaptured() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/localCaptured.kt"); } + @Test @TestMetadata("localDifferentReceivers.kt") public void testLocalDifferentReceivers() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/localDifferentReceivers.kt"); } + @Test @TestMetadata("memberExtension.kt") public void testMemberExtension() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/memberExtension.kt"); } + @Test @TestMetadata("propertyMetadata.kt") public void testPropertyMetadata() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/propertyMetadata.kt"); } + @Test @TestMetadata("provideDelegateByExtensionFunction.kt") public void testProvideDelegateByExtensionFunction() throws Exception { runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/provideDelegateByExtensionFunction.kt"); @@ -10425,261 +11754,269 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/delegation") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Delegation extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Delegation { + @Test public void testAllFilesPresentInDelegation() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("delegationDifferentModule.kt") public void testDelegationDifferentModule() throws Exception { runTest("compiler/testData/codegen/box/delegation/delegationDifferentModule.kt"); } + @Test @TestMetadata("delegationDifferentModule2.kt") public void testDelegationDifferentModule2() throws Exception { runTest("compiler/testData/codegen/box/delegation/delegationDifferentModule2.kt"); } + @Test @TestMetadata("delegationToIntersectionType.kt") public void testDelegationToIntersectionType() throws Exception { runTest("compiler/testData/codegen/box/delegation/delegationToIntersectionType.kt"); } + @Test @TestMetadata("delegationWithPrivateConstructor.kt") public void testDelegationWithPrivateConstructor() throws Exception { runTest("compiler/testData/codegen/box/delegation/delegationWithPrivateConstructor.kt"); } + @Test @TestMetadata("genericProperty.kt") public void testGenericProperty() throws Exception { runTest("compiler/testData/codegen/box/delegation/genericProperty.kt"); } + @Test @TestMetadata("hiddenSuperOverrideIn1.0.kt") public void testHiddenSuperOverrideIn1_0() throws Exception { runTest("compiler/testData/codegen/box/delegation/hiddenSuperOverrideIn1.0.kt"); } + @Test @TestMetadata("inDataClass.kt") public void testInDataClass() throws Exception { runTest("compiler/testData/codegen/box/delegation/inDataClass.kt"); } + @Test @TestMetadata("kt30102_comparable.kt") public void testKt30102_comparable() throws Exception { runTest("compiler/testData/codegen/box/delegation/kt30102_comparable.kt"); } + @Test @TestMetadata("kt8154.kt") public void testKt8154() throws Exception { runTest("compiler/testData/codegen/box/delegation/kt8154.kt"); } + @Test @TestMetadata("smartCastedDelegation.kt") public void testSmartCastedDelegation() throws Exception { runTest("compiler/testData/codegen/box/delegation/smartCastedDelegation.kt"); } + @Test @TestMetadata("viaTypeAlias.kt") public void testViaTypeAlias() throws Exception { runTest("compiler/testData/codegen/box/delegation/viaTypeAlias.kt"); } + @Test @TestMetadata("withDefaultParameters.kt") public void testWithDefaultParameters() throws Exception { runTest("compiler/testData/codegen/box/delegation/withDefaultParameters.kt"); } + @Test @TestMetadata("withDefaultsMultipleFilesOrder.kt") public void testWithDefaultsMultipleFilesOrder() throws Exception { runTest("compiler/testData/codegen/box/delegation/withDefaultsMultipleFilesOrder.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/deprecated") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Deprecated extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Deprecated { + @Test public void testAllFilesPresentInDeprecated() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/deprecated"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/destructuringDeclInLambdaParam") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DestructuringDeclInLambdaParam extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DestructuringDeclInLambdaParam { + @Test public void testAllFilesPresentInDestructuringDeclInLambdaParam() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/destructuringDeclInLambdaParam"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("extensionComponents.kt") public void testExtensionComponents() throws Exception { runTest("compiler/testData/codegen/box/destructuringDeclInLambdaParam/extensionComponents.kt"); } + @Test @TestMetadata("generic.kt") public void testGeneric() throws Exception { runTest("compiler/testData/codegen/box/destructuringDeclInLambdaParam/generic.kt"); } + @Test @TestMetadata("inline.kt") public void testInline() throws Exception { runTest("compiler/testData/codegen/box/destructuringDeclInLambdaParam/inline.kt"); } + @Test @TestMetadata("otherParameters.kt") public void testOtherParameters() throws Exception { runTest("compiler/testData/codegen/box/destructuringDeclInLambdaParam/otherParameters.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/destructuringDeclInLambdaParam/simple.kt"); } + @Test @TestMetadata("stdlibUsages.kt") public void testStdlibUsages() throws Exception { runTest("compiler/testData/codegen/box/destructuringDeclInLambdaParam/stdlibUsages.kt"); } + @Test @TestMetadata("underscoreNames.kt") public void testUnderscoreNames() throws Exception { runTest("compiler/testData/codegen/box/destructuringDeclInLambdaParam/underscoreNames.kt"); } + @Test @TestMetadata("withIndexed.kt") public void testWithIndexed() throws Exception { runTest("compiler/testData/codegen/box/destructuringDeclInLambdaParam/withIndexed.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/diagnostics") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Diagnostics extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Diagnostics { + @Test public void testAllFilesPresentInDiagnostics() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/diagnostics/functions") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Functions extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Functions { + @Test public void testAllFilesPresentInFunctions() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/inference") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Inference extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Inference { + @Test public void testAllFilesPresentInInference() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/inference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt6176.kt") public void testKt6176() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/inference/kt6176.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/invoke") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Invoke extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Invoke { + @Test public void testAllFilesPresentInInvoke() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class OnObjects extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class OnObjects { + @Test public void testAllFilesPresentInOnObjects() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("invokeOnClassObject1.kt") public void testInvokeOnClassObject1() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnClassObject1.kt"); } + @Test @TestMetadata("invokeOnClassObject2.kt") public void testInvokeOnClassObject2() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnClassObject2.kt"); } + @Test @TestMetadata("invokeOnClassObjectOfNestedClass1.kt") public void testInvokeOnClassObjectOfNestedClass1() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnClassObjectOfNestedClass1.kt"); } + @Test @TestMetadata("invokeOnClassObjectOfNestedClass2.kt") public void testInvokeOnClassObjectOfNestedClass2() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnClassObjectOfNestedClass2.kt"); } + @Test @TestMetadata("invokeOnEnum1.kt") public void testInvokeOnEnum1() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnEnum1.kt"); } + @Test @TestMetadata("invokeOnEnum2.kt") public void testInvokeOnEnum2() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnEnum2.kt"); } + @Test @TestMetadata("invokeOnImportedEnum1.kt") public void testInvokeOnImportedEnum1() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnImportedEnum1.kt"); } + @Test @TestMetadata("invokeOnImportedEnum2.kt") public void testInvokeOnImportedEnum2() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnImportedEnum2.kt"); } + @Test @TestMetadata("invokeOnObject1.kt") public void testInvokeOnObject1() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnObject1.kt"); } + @Test @TestMetadata("invokeOnObject2.kt") public void testInvokeOnObject2() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnObject2.kt"); @@ -10687,238 +12024,280 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TailRecursion extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class TailRecursion { + @Test public void testAllFilesPresentInTailRecursion() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/tailRecursion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("defaultArgs.kt") public void testDefaultArgs() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/defaultArgs.kt"); } + @Test @TestMetadata("defaultArgs2.kt") public void testDefaultArgs2() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/defaultArgs2.kt"); } + @Test @TestMetadata("defaultArgsOverridden.kt") public void testDefaultArgsOverridden() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/defaultArgsOverridden.kt"); } + @Test @TestMetadata("defaultArgsWithSideEffects.kt") public void testDefaultArgsWithSideEffects() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/defaultArgsWithSideEffects.kt"); } + @Test @TestMetadata("defaultArgsWithSideEffects2.kt") public void testDefaultArgsWithSideEffects2() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/defaultArgsWithSideEffects2.kt"); } + @Test @TestMetadata("extensionTailCall.kt") public void testExtensionTailCall() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/extensionTailCall.kt"); } + @Test @TestMetadata("functionWithNoTails.kt") public void testFunctionWithNoTails() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/functionWithNoTails.kt"); } + @Test @TestMetadata("functionWithNonTailRecursions.kt") public void testFunctionWithNonTailRecursions() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/functionWithNonTailRecursions.kt"); } + @Test @TestMetadata("functionWithoutAnnotation.kt") public void testFunctionWithoutAnnotation() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/functionWithoutAnnotation.kt"); } + @Test @TestMetadata("infixCall.kt") public void testInfixCall() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/infixCall.kt"); } + @Test @TestMetadata("infixRecursiveCall.kt") public void testInfixRecursiveCall() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/infixRecursiveCall.kt"); } + @Test @TestMetadata("insideElvis.kt") public void testInsideElvis() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/insideElvis.kt"); } + @Test @TestMetadata("kt47084_lambdaInDefaultArgument.kt") public void testKt47084_lambdaInDefaultArgument() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/kt47084_lambdaInDefaultArgument.kt"); } + @Test @TestMetadata("labeledThisReferences.kt") public void testLabeledThisReferences() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/labeledThisReferences.kt"); } + @Test @TestMetadata("loops.kt") public void testLoops() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/loops.kt"); } + @Test @TestMetadata("multilevelBlocks.kt") public void testMultilevelBlocks() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/multilevelBlocks.kt"); } + @Test @TestMetadata("realIteratorFoldl.kt") public void testRealIteratorFoldl() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/realIteratorFoldl.kt"); } + @Test @TestMetadata("realStringEscape.kt") public void testRealStringEscape() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/realStringEscape.kt"); } + @Test @TestMetadata("realStringRepeat.kt") public void testRealStringRepeat() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/realStringRepeat.kt"); } + @Test @TestMetadata("recursiveCallInInlineLambda.kt") public void testRecursiveCallInInlineLambda() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/recursiveCallInInlineLambda.kt"); } + @Test @TestMetadata("recursiveCallInInlineLambdaWithCapture.kt") public void testRecursiveCallInInlineLambdaWithCapture() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/recursiveCallInInlineLambdaWithCapture.kt"); } + @Test @TestMetadata("recursiveCallInLambda.kt") public void testRecursiveCallInLambda() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/recursiveCallInLambda.kt"); } + @Test @TestMetadata("recursiveCallInLocalFunction.kt") public void testRecursiveCallInLocalFunction() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/recursiveCallInLocalFunction.kt"); } + @Test @TestMetadata("recursiveInnerFunction.kt") public void testRecursiveInnerFunction() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/recursiveInnerFunction.kt"); } + @Test @TestMetadata("returnIf.kt") public void testReturnIf() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnIf.kt"); } + @Test @TestMetadata("returnInCatch.kt") public void testReturnInCatch() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInCatch.kt"); } + @Test @TestMetadata("returnInFinally.kt") public void testReturnInFinally() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInFinally.kt"); } + @Test @TestMetadata("returnInIfInFinally.kt") public void testReturnInIfInFinally() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInIfInFinally.kt"); } + @Test @TestMetadata("returnInParentheses.kt") public void testReturnInParentheses() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInParentheses.kt"); } + @Test @TestMetadata("returnInTry.kt") public void testReturnInTry() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInTry.kt"); } + @Test @TestMetadata("simpleBlock.kt") public void testSimpleBlock() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/simpleBlock.kt"); } + @Test @TestMetadata("simpleReturn.kt") public void testSimpleReturn() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/simpleReturn.kt"); } + @Test @TestMetadata("simpleReturnWithElse.kt") public void testSimpleReturnWithElse() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/simpleReturnWithElse.kt"); } + @Test @TestMetadata("sum.kt") public void testSum() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/sum.kt"); } + @Test @TestMetadata("tailCallInBlockInParentheses.kt") public void testTailCallInBlockInParentheses() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/tailCallInBlockInParentheses.kt"); } + @Test @TestMetadata("tailCallInParentheses.kt") public void testTailCallInParentheses() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/tailCallInParentheses.kt"); } + @Test @TestMetadata("tailRecursionInFinally.kt") public void testTailRecursionInFinally() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/tailRecursionInFinally.kt"); } + @Test @TestMetadata("tailrecWithExplicitCompanionObjectDispatcher.kt") public void testTailrecWithExplicitCompanionObjectDispatcher() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/tailrecWithExplicitCompanionObjectDispatcher.kt"); } + @Test @TestMetadata("tailrecWithExplicitObjectDispatcher.kt") public void testTailrecWithExplicitObjectDispatcher() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/tailrecWithExplicitObjectDispatcher.kt"); } + @Test @TestMetadata("thisReferences.kt") public void testThisReferences() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/thisReferences.kt"); } + @Test @TestMetadata("unitBlocks.kt") public void testUnitBlocks() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/unitBlocks.kt"); } + @Test @TestMetadata("whenWithCondition.kt") public void testWhenWithCondition() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithCondition.kt"); } + @Test @TestMetadata("whenWithInRange.kt") public void testWhenWithInRange() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithInRange.kt"); } + @Test @TestMetadata("whenWithIs.kt") public void testWhenWithIs() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithIs.kt"); } + @Test @TestMetadata("whenWithoutCondition.kt") public void testWhenWithoutCondition() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithoutCondition.kt"); @@ -10926,18 +12305,16 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/diagnostics/vararg") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Vararg extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Vararg { + @Test public void testAllFilesPresentInVararg() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/vararg"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt4172.kt") public void testKt4172() throws Exception { runTest("compiler/testData/codegen/box/diagnostics/vararg/kt4172.kt"); @@ -10945,589 +12322,679 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/differentDependencyVersion") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DifferentDependencyVersion extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DifferentDependencyVersion { + @Test public void testAllFilesPresentInDifferentDependencyVersion() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/differentDependencyVersion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/directInvokeOptimization") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DirectInvokeOptimization extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DirectInvokeOptimization { + @Test public void testAllFilesPresentInDirectInvokeOptimization() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/directInvokeOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("boundInnerContructorRef.kt") public void testBoundInnerContructorRef() throws Exception { runTest("compiler/testData/codegen/box/directInvokeOptimization/boundInnerContructorRef.kt"); } + @Test @TestMetadata("boundMemberRef.kt") public void testBoundMemberRef() throws Exception { runTest("compiler/testData/codegen/box/directInvokeOptimization/boundMemberRef.kt"); } + @Test @TestMetadata("canary.kt") public void testCanary() throws Exception { runTest("compiler/testData/codegen/box/directInvokeOptimization/canary.kt"); } + @Test @TestMetadata("capturingLambda.kt") public void testCapturingLambda() throws Exception { runTest("compiler/testData/codegen/box/directInvokeOptimization/capturingLambda.kt"); } + @Test @TestMetadata("contructorRef.kt") public void testContructorRef() throws Exception { runTest("compiler/testData/codegen/box/directInvokeOptimization/contructorRef.kt"); } + @Test @TestMetadata("kt53202.kt") public void testKt53202() throws Exception { runTest("compiler/testData/codegen/box/directInvokeOptimization/kt53202.kt"); } + @Test @TestMetadata("kt53202_funLiteral.kt") public void testKt53202_funLiteral() throws Exception { runTest("compiler/testData/codegen/box/directInvokeOptimization/kt53202_funLiteral.kt"); } + @Test @TestMetadata("kt53202_returns.kt") public void testKt53202_returns() throws Exception { runTest("compiler/testData/codegen/box/directInvokeOptimization/kt53202_returns.kt"); } + @Test @TestMetadata("nestedLambdas.kt") public void testNestedLambdas() throws Exception { runTest("compiler/testData/codegen/box/directInvokeOptimization/nestedLambdas.kt"); } + @Test @TestMetadata("simpleAnonymousFun.kt") public void testSimpleAnonymousFun() throws Exception { runTest("compiler/testData/codegen/box/directInvokeOptimization/simpleAnonymousFun.kt"); } + @Test @TestMetadata("simpleFunRef.kt") public void testSimpleFunRef() throws Exception { runTest("compiler/testData/codegen/box/directInvokeOptimization/simpleFunRef.kt"); } + @Test @TestMetadata("simpleLambda.kt") public void testSimpleLambda() throws Exception { runTest("compiler/testData/codegen/box/directInvokeOptimization/simpleLambda.kt"); } + @Test @TestMetadata("unboundInnerContructorRef.kt") public void testUnboundInnerContructorRef() throws Exception { runTest("compiler/testData/codegen/box/directInvokeOptimization/unboundInnerContructorRef.kt"); } + @Test @TestMetadata("unboundMemberRef.kt") public void testUnboundMemberRef() throws Exception { runTest("compiler/testData/codegen/box/directInvokeOptimization/unboundMemberRef.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/elvis") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Elvis extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Elvis { + @Test public void testAllFilesPresentInElvis() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/elvis"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("genericElvisWithMoreSpecificLHS.kt") public void testGenericElvisWithMoreSpecificLHS() throws Exception { runTest("compiler/testData/codegen/box/elvis/genericElvisWithMoreSpecificLHS.kt"); } + @Test @TestMetadata("genericElvisWithNullLHS.kt") public void testGenericElvisWithNullLHS() throws Exception { runTest("compiler/testData/codegen/box/elvis/genericElvisWithNullLHS.kt"); } + @Test @TestMetadata("genericNull.kt") public void testGenericNull() throws Exception { runTest("compiler/testData/codegen/box/elvis/genericNull.kt"); } + @Test @TestMetadata("kt24209.kt") public void testKt24209() throws Exception { runTest("compiler/testData/codegen/box/elvis/kt24209.kt"); } + @Test @TestMetadata("kt6694ExactAnnotationForElvis.kt") public void testKt6694ExactAnnotationForElvis() throws Exception { runTest("compiler/testData/codegen/box/elvis/kt6694ExactAnnotationForElvis.kt"); } + @Test @TestMetadata("nullNullOk.kt") public void testNullNullOk() throws Exception { runTest("compiler/testData/codegen/box/elvis/nullNullOk.kt"); } + @Test @TestMetadata("ofNonNullableResultType.kt") public void testOfNonNullableResultType() throws Exception { runTest("compiler/testData/codegen/box/elvis/ofNonNullableResultType.kt"); } + @Test @TestMetadata("primitive.kt") public void testPrimitive() throws Exception { runTest("compiler/testData/codegen/box/elvis/primitive.kt"); } + @Test @TestMetadata("withReturn.kt") public void testWithReturn() throws Exception { runTest("compiler/testData/codegen/box/elvis/withReturn.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/enum") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Enum extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Enum { + @Test @TestMetadata("abstractMethodInEnum.kt") public void testAbstractMethodInEnum() throws Exception { runTest("compiler/testData/codegen/box/enum/abstractMethodInEnum.kt"); } + @Test @TestMetadata("abstractNestedClass.kt") public void testAbstractNestedClass() throws Exception { runTest("compiler/testData/codegen/box/enum/abstractNestedClass.kt"); } + @Test public void testAllFilesPresentInEnum() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("asReturnExpression.kt") public void testAsReturnExpression() throws Exception { runTest("compiler/testData/codegen/box/enum/asReturnExpression.kt"); } + @Test @TestMetadata("companionAccessingEnumValue.kt") public void testCompanionAccessingEnumValue() throws Exception { runTest("compiler/testData/codegen/box/enum/companionAccessingEnumValue.kt"); } + @Test @TestMetadata("companionObjectInEnum.kt") public void testCompanionObjectInEnum() throws Exception { runTest("compiler/testData/codegen/box/enum/companionObjectInEnum.kt"); } + @Test @TestMetadata("constructorWithReordering.kt") public void testConstructorWithReordering() throws Exception { runTest("compiler/testData/codegen/box/enum/constructorWithReordering.kt"); } + @Test @TestMetadata("deepInnerClassInEnumEntryClass.kt") public void testDeepInnerClassInEnumEntryClass() throws Exception { runTest("compiler/testData/codegen/box/enum/deepInnerClassInEnumEntryClass.kt"); } + @Test @TestMetadata("deepInnerClassInEnumEntryClass2.kt") public void testDeepInnerClassInEnumEntryClass2() throws Exception { runTest("compiler/testData/codegen/box/enum/deepInnerClassInEnumEntryClass2.kt"); } + @Test @TestMetadata("emptyConstructor.kt") public void testEmptyConstructor() throws Exception { runTest("compiler/testData/codegen/box/enum/emptyConstructor.kt"); } + @Test @TestMetadata("emptyEnumValuesValueOf.kt") public void testEmptyEnumValuesValueOf() throws Exception { runTest("compiler/testData/codegen/box/enum/emptyEnumValuesValueOf.kt"); } + @Test @TestMetadata("enumCompanionInitJsAndWasm.kt") public void testEnumCompanionInitJsAndWasm() throws Exception { runTest("compiler/testData/codegen/box/enum/enumCompanionInitJsAndWasm.kt"); } + @Test @TestMetadata("enumConstructorParameterClashWithDefaults.kt") public void testEnumConstructorParameterClashWithDefaults() throws Exception { runTest("compiler/testData/codegen/box/enum/enumConstructorParameterClashWithDefaults.kt"); } + @Test @TestMetadata("enumEntries.kt") public void testEnumEntries() throws Exception { runTest("compiler/testData/codegen/box/enum/enumEntries.kt"); } + @Test @TestMetadata("enumEntriesCompatibilityCheck.kt") public void testEnumEntriesCompatibilityCheck() throws Exception { runTest("compiler/testData/codegen/box/enum/enumEntriesCompatibilityCheck.kt"); } + @Test @TestMetadata("enumEntriesInCompanion.kt") public void testEnumEntriesInCompanion() throws Exception { runTest("compiler/testData/codegen/box/enum/enumEntriesInCompanion.kt"); } + @Test @TestMetadata("enumEntriesMultimoduleNoMappings.kt") public void testEnumEntriesMultimoduleNoMappings() throws Exception { runTest("compiler/testData/codegen/box/enum/enumEntriesMultimoduleNoMappings.kt"); } + @Test @TestMetadata("enumEntriesNameClashes.kt") public void testEnumEntriesNameClashes() throws Exception { runTest("compiler/testData/codegen/box/enum/enumEntriesNameClashes.kt"); } + @Test @TestMetadata("enumEntryHashCode.kt") public void testEnumEntryHashCode() throws Exception { runTest("compiler/testData/codegen/box/enum/enumEntryHashCode.kt"); } + @Test @TestMetadata("enumEntryMembers.kt") public void testEnumEntryMembers() throws Exception { runTest("compiler/testData/codegen/box/enum/enumEntryMembers.kt"); } + @Test @TestMetadata("enumEntryReferenceFromInnerClassConstructor1.kt") public void testEnumEntryReferenceFromInnerClassConstructor1() throws Exception { runTest("compiler/testData/codegen/box/enum/enumEntryReferenceFromInnerClassConstructor1.kt"); } + @Test @TestMetadata("enumEntryReferenceFromInnerClassConstructor2.kt") public void testEnumEntryReferenceFromInnerClassConstructor2() throws Exception { runTest("compiler/testData/codegen/box/enum/enumEntryReferenceFromInnerClassConstructor2.kt"); } + @Test @TestMetadata("enumEntryReferenceFromInnerClassConstructor3.kt") public void testEnumEntryReferenceFromInnerClassConstructor3() throws Exception { runTest("compiler/testData/codegen/box/enum/enumEntryReferenceFromInnerClassConstructor3.kt"); } + @Test @TestMetadata("enumInheritedFromTrait.kt") public void testEnumInheritedFromTrait() throws Exception { runTest("compiler/testData/codegen/box/enum/enumInheritedFromTrait.kt"); } + @Test @TestMetadata("enumMultiModule.kt") public void testEnumMultiModule() throws Exception { runTest("compiler/testData/codegen/box/enum/enumMultiModule.kt"); } + @Test @TestMetadata("enumShort.kt") public void testEnumShort() throws Exception { runTest("compiler/testData/codegen/box/enum/enumShort.kt"); } + @Test @TestMetadata("enumValueOf.kt") public void testEnumValueOf() throws Exception { runTest("compiler/testData/codegen/box/enum/enumValueOf.kt"); } + @Test @TestMetadata("enumWithLambdaParameter.kt") public void testEnumWithLambdaParameter() throws Exception { runTest("compiler/testData/codegen/box/enum/enumWithLambdaParameter.kt"); } + @Test @TestMetadata("getEnumEntityByOrdinal.kt") public void testGetEnumEntityByOrdinal() throws Exception { runTest("compiler/testData/codegen/box/enum/getEnumEntityByOrdinal.kt"); } + @Test @TestMetadata("inPackage.kt") public void testInPackage() throws Exception { runTest("compiler/testData/codegen/box/enum/inPackage.kt"); } + @Test @TestMetadata("inclassobj.kt") public void testInclassobj() throws Exception { runTest("compiler/testData/codegen/box/enum/inclassobj.kt"); } + @Test @TestMetadata("initEntriesInCompanionObject.kt") public void testInitEntriesInCompanionObject() throws Exception { runTest("compiler/testData/codegen/box/enum/initEntriesInCompanionObject.kt"); } + @Test @TestMetadata("initEntriesInCompanionObject2.kt") public void testInitEntriesInCompanionObject2() throws Exception { runTest("compiler/testData/codegen/box/enum/initEntriesInCompanionObject2.kt"); } + @Test @TestMetadata("initEntriesInValueOf.kt") public void testInitEntriesInValueOf() throws Exception { runTest("compiler/testData/codegen/box/enum/initEntriesInValueOf.kt"); } + @Test @TestMetadata("initEnumAfterObjectAccessJsAndWasm.kt") public void testInitEnumAfterObjectAccessJsAndWasm() throws Exception { runTest("compiler/testData/codegen/box/enum/initEnumAfterObjectAccessJsAndWasm.kt"); } + @Test @TestMetadata("inner.kt") public void testInner() throws Exception { runTest("compiler/testData/codegen/box/enum/inner.kt"); } + @Test @TestMetadata("innerClassInEnumEntryClass.kt") public void testInnerClassInEnumEntryClass() throws Exception { runTest("compiler/testData/codegen/box/enum/innerClassInEnumEntryClass.kt"); } + @Test @TestMetadata("innerClassMethodInEnumEntryClass.kt") public void testInnerClassMethodInEnumEntryClass() throws Exception { runTest("compiler/testData/codegen/box/enum/innerClassMethodInEnumEntryClass.kt"); } + @Test @TestMetadata("innerClassMethodInEnumEntryClass2.kt") public void testInnerClassMethodInEnumEntryClass2() throws Exception { runTest("compiler/testData/codegen/box/enum/innerClassMethodInEnumEntryClass2.kt"); } + @Test @TestMetadata("innerWithExistingClassObject.kt") public void testInnerWithExistingClassObject() throws Exception { runTest("compiler/testData/codegen/box/enum/innerWithExistingClassObject.kt"); } + @Test @TestMetadata("k54079.kt") public void testK54079() throws Exception { runTest("compiler/testData/codegen/box/enum/k54079.kt"); } + @Test @TestMetadata("kt1119.kt") public void testKt1119() throws Exception { runTest("compiler/testData/codegen/box/enum/kt1119.kt"); } + @Test @TestMetadata("kt18731.kt") public void testKt18731() throws Exception { runTest("compiler/testData/codegen/box/enum/kt18731.kt"); } + @Test @TestMetadata("kt18731_2.kt") public void testKt18731_2() throws Exception { runTest("compiler/testData/codegen/box/enum/kt18731_2.kt"); } + @Test @TestMetadata("kt20651.kt") public void testKt20651() throws Exception { runTest("compiler/testData/codegen/box/enum/kt20651.kt"); } + @Test @TestMetadata("kt20651_inlineLambda.kt") public void testKt20651_inlineLambda() throws Exception { runTest("compiler/testData/codegen/box/enum/kt20651_inlineLambda.kt"); } + @Test @TestMetadata("kt20651a.kt") public void testKt20651a() throws Exception { runTest("compiler/testData/codegen/box/enum/kt20651a.kt"); } + @Test @TestMetadata("kt20651b.kt") public void testKt20651b() throws Exception { runTest("compiler/testData/codegen/box/enum/kt20651b.kt"); } + @Test @TestMetadata("kt2350.kt") public void testKt2350() throws Exception { runTest("compiler/testData/codegen/box/enum/kt2350.kt"); } + @Test @TestMetadata("kt38996.kt") public void testKt38996() throws Exception { runTest("compiler/testData/codegen/box/enum/kt38996.kt"); } + @Test @TestMetadata("kt44744.kt") public void testKt44744() throws Exception { runTest("compiler/testData/codegen/box/enum/kt44744.kt"); } + @Test @TestMetadata("kt44744_innerClass.kt") public void testKt44744_innerClass() throws Exception { runTest("compiler/testData/codegen/box/enum/kt44744_innerClass.kt"); } + @Test @TestMetadata("kt46605.kt") public void testKt46605() throws Exception { runTest("compiler/testData/codegen/box/enum/kt46605.kt"); } + @Test @TestMetadata("kt7257.kt") public void testKt7257() throws Exception { runTest("compiler/testData/codegen/box/enum/kt7257.kt"); } + @Test @TestMetadata("kt7257_anonObjectInit.kt") public void testKt7257_anonObjectInit() throws Exception { runTest("compiler/testData/codegen/box/enum/kt7257_anonObjectInit.kt"); } + @Test @TestMetadata("kt7257_anonObjectMethod.kt") public void testKt7257_anonObjectMethod() throws Exception { runTest("compiler/testData/codegen/box/enum/kt7257_anonObjectMethod.kt"); } + @Test @TestMetadata("kt7257_boundReference1.kt") public void testKt7257_boundReference1() throws Exception { runTest("compiler/testData/codegen/box/enum/kt7257_boundReference1.kt"); } + @Test @TestMetadata("kt7257_boundReference2.kt") public void testKt7257_boundReference2() throws Exception { runTest("compiler/testData/codegen/box/enum/kt7257_boundReference2.kt"); } + @Test @TestMetadata("kt7257_boundReferenceWithImplicitReceiver.kt") public void testKt7257_boundReferenceWithImplicitReceiver() throws Exception { runTest("compiler/testData/codegen/box/enum/kt7257_boundReferenceWithImplicitReceiver.kt"); } + @Test @TestMetadata("kt7257_explicitReceiver.kt") public void testKt7257_explicitReceiver() throws Exception { runTest("compiler/testData/codegen/box/enum/kt7257_explicitReceiver.kt"); } + @Test @TestMetadata("kt7257_fullyQualifiedReceiver.kt") public void testKt7257_fullyQualifiedReceiver() throws Exception { runTest("compiler/testData/codegen/box/enum/kt7257_fullyQualifiedReceiver.kt"); } + @Test @TestMetadata("kt7257_namedLocalFun.kt") public void testKt7257_namedLocalFun() throws Exception { runTest("compiler/testData/codegen/box/enum/kt7257_namedLocalFun.kt"); } + @Test @TestMetadata("kt7257_notInline.kt") public void testKt7257_notInline() throws Exception { runTest("compiler/testData/codegen/box/enum/kt7257_notInline.kt"); } + @Test @TestMetadata("kt9711.kt") public void testKt9711() throws Exception { runTest("compiler/testData/codegen/box/enum/kt9711.kt"); } + @Test @TestMetadata("kt9711_2.kt") public void testKt9711_2() throws Exception { runTest("compiler/testData/codegen/box/enum/kt9711_2.kt"); } + @Test @TestMetadata("manyDefaultParameters.kt") public void testManyDefaultParameters() throws Exception { runTest("compiler/testData/codegen/box/enum/manyDefaultParameters.kt"); } + @Test @TestMetadata("ordinal.kt") public void testOrdinal() throws Exception { runTest("compiler/testData/codegen/box/enum/ordinal.kt"); } + @Test @TestMetadata("ordinalsWithEnumEntitiesOverrides.kt") public void testOrdinalsWithEnumEntitiesOverrides() throws Exception { runTest("compiler/testData/codegen/box/enum/ordinalsWithEnumEntitiesOverrides.kt"); } + @Test @TestMetadata("overloadedEnumValues.kt") public void testOverloadedEnumValues() throws Exception { runTest("compiler/testData/codegen/box/enum/overloadedEnumValues.kt"); } + @Test @TestMetadata("refToThis.kt") public void testRefToThis() throws Exception { runTest("compiler/testData/codegen/box/enum/refToThis.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/enum/simple.kt"); } + @Test @TestMetadata("sortEnumEntries.kt") public void testSortEnumEntries() throws Exception { runTest("compiler/testData/codegen/box/enum/sortEnumEntries.kt"); } + @Test @TestMetadata("superCallInEnumLiteral.kt") public void testSuperCallInEnumLiteral() throws Exception { runTest("compiler/testData/codegen/box/enum/superCallInEnumLiteral.kt"); } + @Test @TestMetadata("toString.kt") public void testToString() throws Exception { runTest("compiler/testData/codegen/box/enum/toString.kt"); } + @Test @TestMetadata("valueof.kt") public void testValueof() throws Exception { runTest("compiler/testData/codegen/box/enum/valueof.kt"); } + @Test @TestMetadata("whenInObject.kt") public void testWhenInObject() throws Exception { runTest("compiler/testData/codegen/box/enum/whenInObject.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/enum/defaultCtor") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DefaultCtor extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DefaultCtor { + @Test public void testAllFilesPresentInDefaultCtor() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum/defaultCtor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("constructorWithDefaultArguments.kt") public void testConstructorWithDefaultArguments() throws Exception { runTest("compiler/testData/codegen/box/enum/defaultCtor/constructorWithDefaultArguments.kt"); } + @Test @TestMetadata("constructorWithVararg.kt") public void testConstructorWithVararg() throws Exception { runTest("compiler/testData/codegen/box/enum/defaultCtor/constructorWithVararg.kt"); } + @Test @TestMetadata("entryClassConstructorWithDefaultArguments.kt") public void testEntryClassConstructorWithDefaultArguments() throws Exception { runTest("compiler/testData/codegen/box/enum/defaultCtor/entryClassConstructorWithDefaultArguments.kt"); } + @Test @TestMetadata("entryClassConstructorWithVarargs.kt") public void testEntryClassConstructorWithVarargs() throws Exception { runTest("compiler/testData/codegen/box/enum/defaultCtor/entryClassConstructorWithVarargs.kt"); } + @Test @TestMetadata("noPrimaryConstructor.kt") public void testNoPrimaryConstructor() throws Exception { runTest("compiler/testData/codegen/box/enum/defaultCtor/noPrimaryConstructor.kt"); } + @Test @TestMetadata("secondaryConstructorWithDefaultArguments.kt") public void testSecondaryConstructorWithDefaultArguments() throws Exception { runTest("compiler/testData/codegen/box/enum/defaultCtor/secondaryConstructorWithDefaultArguments.kt"); } + @Test @TestMetadata("secondaryConstructorWithVararg.kt") public void testSecondaryConstructorWithVararg() throws Exception { runTest("compiler/testData/codegen/box/enum/defaultCtor/secondaryConstructorWithVararg.kt"); @@ -11535,237 +13002,251 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/evaluate") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Evaluate extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Evaluate { + @Test public void testAllFilesPresentInEvaluate() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/evaluate"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt9443.kt") public void testKt9443() throws Exception { runTest("compiler/testData/codegen/box/evaluate/kt9443.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/exclExcl") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ExclExcl extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ExclExcl { + @Test public void testAllFilesPresentInExclExcl() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/exclExcl"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("genericNull.kt") public void testGenericNull() throws Exception { runTest("compiler/testData/codegen/box/exclExcl/genericNull.kt"); } + @Test @TestMetadata("kt48440.kt") public void testKt48440() throws Exception { runTest("compiler/testData/codegen/box/exclExcl/kt48440.kt"); } + @Test @TestMetadata("kt48440_2.kt") public void testKt48440_2() throws Exception { runTest("compiler/testData/codegen/box/exclExcl/kt48440_2.kt"); } + @Test @TestMetadata("primitive.kt") public void testPrimitive() throws Exception { runTest("compiler/testData/codegen/box/exclExcl/primitive.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/extensionClasses") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ExtensionClasses extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ExtensionClasses { + @Test public void testAllFilesPresentInExtensionClasses() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/extensionFunctions") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ExtensionFunctions extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ExtensionFunctions { + @Test public void testAllFilesPresentInExtensionFunctions() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionFunctions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("classMethodCallExtensionSuper.kt") public void testClassMethodCallExtensionSuper() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/classMethodCallExtensionSuper.kt"); } + @Test @TestMetadata("defaultMethodInterfaceCallExtensionSuper.kt") public void testDefaultMethodInterfaceCallExtensionSuper() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/defaultMethodInterfaceCallExtensionSuper.kt"); } + @Test @TestMetadata("executionOrder.kt") public void testExecutionOrder() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/executionOrder.kt"); } + @Test @TestMetadata("extensionFunctionAsSupertype.kt") public void testExtensionFunctionAsSupertype() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/extensionFunctionAsSupertype.kt"); } + @Test @TestMetadata("kt1061.kt") public void testKt1061() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/kt1061.kt"); } + @Test @TestMetadata("kt1249.kt") public void testKt1249() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/kt1249.kt"); } + @Test @TestMetadata("kt1290.kt") public void testKt1290() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/kt1290.kt"); } + @Test @TestMetadata("kt13312.kt") public void testKt13312() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/kt13312.kt"); } + @Test @TestMetadata("kt1776.kt") public void testKt1776() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/kt1776.kt"); } + @Test @TestMetadata("kt1953.kt") public void testKt1953() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/kt1953.kt"); } + @Test @TestMetadata("kt1953_class.kt") public void testKt1953_class() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/kt1953_class.kt"); } + @Test @TestMetadata("kt23675.kt") public void testKt23675() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/kt23675.kt"); } + @Test @TestMetadata("kt3285.kt") public void testKt3285() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/kt3285.kt"); } + @Test @TestMetadata("kt3298.kt") public void testKt3298() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/kt3298.kt"); } + @Test @TestMetadata("kt3646.kt") public void testKt3646() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/kt3646.kt"); } + @Test @TestMetadata("kt3969.kt") public void testKt3969() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/kt3969.kt"); } + @Test @TestMetadata("kt4228.kt") public void testKt4228() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/kt4228.kt"); } + @Test @TestMetadata("kt475.kt") public void testKt475() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/kt475.kt"); } + @Test @TestMetadata("kt5467.kt") public void testKt5467() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/kt5467.kt"); } + @Test @TestMetadata("kt606.kt") public void testKt606() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/kt606.kt"); } + @Test @TestMetadata("kt865.kt") public void testKt865() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/kt865.kt"); } + @Test @TestMetadata("memberExtensionEqualsHashCodeToStringInInterface.kt") public void testMemberExtensionEqualsHashCodeToStringInInterface() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/memberExtensionEqualsHashCodeToStringInInterface.kt"); } + @Test @TestMetadata("nested2.kt") public void testNested2() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/nested2.kt"); } + @Test @TestMetadata("shared.kt") public void testShared() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/shared.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/simple.kt"); } + @Test @TestMetadata("thisMethodInObjectLiteral.kt") public void testThisMethodInObjectLiteral() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/thisMethodInObjectLiteral.kt"); } + @Test @TestMetadata("virtual.kt") public void testVirtual() throws Exception { runTest("compiler/testData/codegen/box/extensionFunctions/virtual.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/extensionFunctions/contextReceivers") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ContextReceivers extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ContextReceivers { + @Test public void testAllFilesPresentInContextReceivers() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionFunctions/contextReceivers"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/extensionFunctions/contextReceivers/fromKEEP") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class FromKEEP extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class FromKEEP { + @Test public void testAllFilesPresentInFromKEEP() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionFunctions/contextReceivers/fromKEEP"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @@ -11773,617 +13254,679 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/extensionProperties") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ExtensionProperties extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ExtensionProperties { + @Test @TestMetadata("accessorForPrivateSetter.kt") public void testAccessorForPrivateSetter() throws Exception { runTest("compiler/testData/codegen/box/extensionProperties/accessorForPrivateSetter.kt"); } + @Test public void testAllFilesPresentInExtensionProperties() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionProperties"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("genericValForPrimitiveType.kt") public void testGenericValForPrimitiveType() throws Exception { runTest("compiler/testData/codegen/box/extensionProperties/genericValForPrimitiveType.kt"); } + @Test @TestMetadata("genericVarForPrimitiveType.kt") public void testGenericVarForPrimitiveType() throws Exception { runTest("compiler/testData/codegen/box/extensionProperties/genericVarForPrimitiveType.kt"); } + @Test @TestMetadata("inClass.kt") public void testInClass() throws Exception { runTest("compiler/testData/codegen/box/extensionProperties/inClass.kt"); } + @Test @TestMetadata("inClassLongTypeInReceiver.kt") public void testInClassLongTypeInReceiver() throws Exception { runTest("compiler/testData/codegen/box/extensionProperties/inClassLongTypeInReceiver.kt"); } + @Test @TestMetadata("inClassWithGetter.kt") public void testInClassWithGetter() throws Exception { runTest("compiler/testData/codegen/box/extensionProperties/inClassWithGetter.kt"); } + @Test @TestMetadata("inClassWithPrivateGetter.kt") public void testInClassWithPrivateGetter() throws Exception { runTest("compiler/testData/codegen/box/extensionProperties/inClassWithPrivateGetter.kt"); } + @Test @TestMetadata("inClassWithPrivateSetter.kt") public void testInClassWithPrivateSetter() throws Exception { runTest("compiler/testData/codegen/box/extensionProperties/inClassWithPrivateSetter.kt"); } + @Test @TestMetadata("inClassWithSetter.kt") public void testInClassWithSetter() throws Exception { runTest("compiler/testData/codegen/box/extensionProperties/inClassWithSetter.kt"); } + @Test @TestMetadata("kt46952.kt") public void testKt46952() throws Exception { runTest("compiler/testData/codegen/box/extensionProperties/kt46952.kt"); } + @Test @TestMetadata("kt9897.kt") public void testKt9897() throws Exception { runTest("compiler/testData/codegen/box/extensionProperties/kt9897.kt"); } + @Test @TestMetadata("kt9897_topLevel.kt") public void testKt9897_topLevel() throws Exception { runTest("compiler/testData/codegen/box/extensionProperties/kt9897_topLevel.kt"); } + @Test @TestMetadata("nonAbstractInInterface.kt") public void testNonAbstractInInterface() throws Exception { runTest("compiler/testData/codegen/box/extensionProperties/nonAbstractInInterface.kt"); } + @Test @TestMetadata("topLevel.kt") public void testTopLevel() throws Exception { runTest("compiler/testData/codegen/box/extensionProperties/topLevel.kt"); } + @Test @TestMetadata("topLevelLongTypeInReceiver.kt") public void testTopLevelLongTypeInReceiver() throws Exception { runTest("compiler/testData/codegen/box/extensionProperties/topLevelLongTypeInReceiver.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/external") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class External extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class External { + @Test public void testAllFilesPresentInExternal() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/external"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/fakeOverride") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class FakeOverride extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class FakeOverride { + @Test public void testAllFilesPresentInFakeOverride() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fakeOverride"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("diamondFunction.kt") public void testDiamondFunction() throws Exception { runTest("compiler/testData/codegen/box/fakeOverride/diamondFunction.kt"); } + @Test @TestMetadata("function.kt") public void testFunction() throws Exception { runTest("compiler/testData/codegen/box/fakeOverride/function.kt"); } + @Test @TestMetadata("internalFromFriendModule.kt") public void testInternalFromFriendModule() throws Exception { runTest("compiler/testData/codegen/box/fakeOverride/internalFromFriendModule.kt"); } + @Test @TestMetadata("kt49371.kt") public void testKt49371() throws Exception { runTest("compiler/testData/codegen/box/fakeOverride/kt49371.kt"); } + @Test @TestMetadata("privateFakeOverrides0.kt") public void testPrivateFakeOverrides0() throws Exception { runTest("compiler/testData/codegen/box/fakeOverride/privateFakeOverrides0.kt"); } + @Test @TestMetadata("privateFakeOverrides1.kt") public void testPrivateFakeOverrides1() throws Exception { runTest("compiler/testData/codegen/box/fakeOverride/privateFakeOverrides1.kt"); } + @Test @TestMetadata("propertyGetter.kt") public void testPropertyGetter() throws Exception { runTest("compiler/testData/codegen/box/fakeOverride/propertyGetter.kt"); } + @Test @TestMetadata("propertySetter.kt") public void testPropertySetter() throws Exception { runTest("compiler/testData/codegen/box/fakeOverride/propertySetter.kt"); } + @Test @TestMetadata("varianceOverload.kt") public void testVarianceOverload() throws Exception { runTest("compiler/testData/codegen/box/fakeOverride/varianceOverload.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/fieldRename") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class FieldRename extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class FieldRename { + @Test public void testAllFilesPresentInFieldRename() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fieldRename"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("constructorAndClassObject.kt") public void testConstructorAndClassObject() throws Exception { runTest("compiler/testData/codegen/box/fieldRename/constructorAndClassObject.kt"); } + @Test @TestMetadata("delegates.kt") public void testDelegates() throws Exception { runTest("compiler/testData/codegen/box/fieldRename/delegates.kt"); } + @Test @TestMetadata("genericPropertyWithItself.kt") public void testGenericPropertyWithItself() throws Exception { runTest("compiler/testData/codegen/box/fieldRename/genericPropertyWithItself.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/finally") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Finally extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Finally { + @Test public void testAllFilesPresentInFinally() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/finally"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("breakAndOuterFinally.kt") public void testBreakAndOuterFinally() throws Exception { runTest("compiler/testData/codegen/box/finally/breakAndOuterFinally.kt"); } + @Test @TestMetadata("continueAndOuterFinally.kt") public void testContinueAndOuterFinally() throws Exception { runTest("compiler/testData/codegen/box/finally/continueAndOuterFinally.kt"); } + @Test @TestMetadata("finallyAndFinally.kt") public void testFinallyAndFinally() throws Exception { runTest("compiler/testData/codegen/box/finally/finallyAndFinally.kt"); } + @Test @TestMetadata("kt31923_break.kt") public void testKt31923_break() throws Exception { runTest("compiler/testData/codegen/box/finally/kt31923_break.kt"); } + @Test @TestMetadata("kt31923_continue.kt") public void testKt31923_continue() throws Exception { runTest("compiler/testData/codegen/box/finally/kt31923_continue.kt"); } + @Test @TestMetadata("kt31923_return.kt") public void testKt31923_return() throws Exception { runTest("compiler/testData/codegen/box/finally/kt31923_return.kt"); } + @Test @TestMetadata("kt3549.kt") public void testKt3549() throws Exception { runTest("compiler/testData/codegen/box/finally/kt3549.kt"); } + @Test @TestMetadata("kt3706.kt") public void testKt3706() throws Exception { runTest("compiler/testData/codegen/box/finally/kt3706.kt"); } + @Test @TestMetadata("kt3867.kt") public void testKt3867() throws Exception { runTest("compiler/testData/codegen/box/finally/kt3867.kt"); } + @Test @TestMetadata("kt3874.kt") public void testKt3874() throws Exception { runTest("compiler/testData/codegen/box/finally/kt3874.kt"); } + @Test @TestMetadata("kt3894.kt") public void testKt3894() throws Exception { runTest("compiler/testData/codegen/box/finally/kt3894.kt"); } + @Test @TestMetadata("kt4134.kt") public void testKt4134() throws Exception { runTest("compiler/testData/codegen/box/finally/kt4134.kt"); } + @Test @TestMetadata("loopAndFinally.kt") public void testLoopAndFinally() throws Exception { runTest("compiler/testData/codegen/box/finally/loopAndFinally.kt"); } + @Test @TestMetadata("nestedFinallyAndNonFinallyTry.kt") public void testNestedFinallyAndNonFinallyTry() throws Exception { runTest("compiler/testData/codegen/box/finally/nestedFinallyAndNonFinallyTry.kt"); } + @Test @TestMetadata("nestedFinallyAndNonFinallyTry2.kt") public void testNestedFinallyAndNonFinallyTry2() throws Exception { runTest("compiler/testData/codegen/box/finally/nestedFinallyAndNonFinallyTry2.kt"); } + @Test @TestMetadata("nestedFinallyAndNonFinallyTry3.kt") public void testNestedFinallyAndNonFinallyTry3() throws Exception { runTest("compiler/testData/codegen/box/finally/nestedFinallyAndNonFinallyTry3.kt"); } + @Test @TestMetadata("nestedFinallyAndNonFinallyTry4.kt") public void testNestedFinallyAndNonFinallyTry4() throws Exception { runTest("compiler/testData/codegen/box/finally/nestedFinallyAndNonFinallyTry4.kt"); } + @Test @TestMetadata("notChainCatch.kt") public void testNotChainCatch() throws Exception { runTest("compiler/testData/codegen/box/finally/notChainCatch.kt"); } + @Test @TestMetadata("objectInFinally.kt") public void testObjectInFinally() throws Exception { runTest("compiler/testData/codegen/box/finally/objectInFinally.kt"); } + @Test @TestMetadata("returnNullFromInlined.kt") public void testReturnNullFromInlined() throws Exception { runTest("compiler/testData/codegen/box/finally/returnNullFromInlined.kt"); } + @Test @TestMetadata("someStuff.kt") public void testSomeStuff() throws Exception { runTest("compiler/testData/codegen/box/finally/someStuff.kt"); } + @Test @TestMetadata("tryFinally.kt") public void testTryFinally() throws Exception { runTest("compiler/testData/codegen/box/finally/tryFinally.kt"); } + @Test @TestMetadata("tryLoopTry.kt") public void testTryLoopTry() throws Exception { runTest("compiler/testData/codegen/box/finally/tryLoopTry.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/fir") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Fir extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Fir { + @Test public void testAllFilesPresentInFir() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fir"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("anonymousOverrideWithDefaultInLocalOverridden.kt") public void testAnonymousOverrideWithDefaultInLocalOverridden() throws Exception { runTest("compiler/testData/codegen/box/fir/anonymousOverrideWithDefaultInLocalOverridden.kt"); } + @Test @TestMetadata("anonymousOverrideWithDefaultInOverridden.kt") public void testAnonymousOverrideWithDefaultInOverridden() throws Exception { runTest("compiler/testData/codegen/box/fir/anonymousOverrideWithDefaultInOverridden.kt"); } + @Test @TestMetadata("classCanNotBeCastedToVoid.kt") public void testClassCanNotBeCastedToVoid() throws Exception { runTest("compiler/testData/codegen/box/fir/classCanNotBeCastedToVoid.kt"); } + @Test @TestMetadata("deserializedOptInDeprecated.kt") public void testDeserializedOptInDeprecated() throws Exception { runTest("compiler/testData/codegen/box/fir/deserializedOptInDeprecated.kt"); } + @Test @TestMetadata("falsePositiveBoundSmartcast.kt") public void testFalsePositiveBoundSmartcast() throws Exception { runTest("compiler/testData/codegen/box/fir/falsePositiveBoundSmartcast.kt"); } + @Test @TestMetadata("localOverrideWithDefaultInLocalOverridden.kt") public void testLocalOverrideWithDefaultInLocalOverridden() throws Exception { runTest("compiler/testData/codegen/box/fir/localOverrideWithDefaultInLocalOverridden.kt"); } + @Test @TestMetadata("localOverrideWithDefaultInOverridden.kt") public void testLocalOverrideWithDefaultInOverridden() throws Exception { runTest("compiler/testData/codegen/box/fir/localOverrideWithDefaultInOverridden.kt"); } + @Test @TestMetadata("nestedClassTypeParameterDeserialization.kt") public void testNestedClassTypeParameterDeserialization() throws Exception { runTest("compiler/testData/codegen/box/fir/nestedClassTypeParameterDeserialization.kt"); } + @Test @TestMetadata("SamWithReceiverMavenProjectImportHandler.kt") public void testSamWithReceiverMavenProjectImportHandler() throws Exception { runTest("compiler/testData/codegen/box/fir/SamWithReceiverMavenProjectImportHandler.kt"); } + @Test @TestMetadata("toLong.kt") public void testToLong() throws Exception { runTest("compiler/testData/codegen/box/fir/toLong.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/fullJdk") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class FullJdk extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class FullJdk { + @Test public void testAllFilesPresentInFullJdk() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/fullJdk/native") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Native extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Native { + @Test public void testAllFilesPresentInNative() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/native"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/fullJdk/regressions") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Regressions extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Regressions { + @Test public void testAllFilesPresentInRegressions() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/regressions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/funInterface") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class FunInterface extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class FunInterface { + @Test public void testAllFilesPresentInFunInterface() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("basicFunInterface.kt") public void testBasicFunInterface() throws Exception { runTest("compiler/testData/codegen/box/funInterface/basicFunInterface.kt"); } + @Test @TestMetadata("basicFunInterfaceConversion.kt") public void testBasicFunInterfaceConversion() throws Exception { runTest("compiler/testData/codegen/box/funInterface/basicFunInterfaceConversion.kt"); } + @Test @TestMetadata("basicFunInterfaceConversionClash.kt") public void testBasicFunInterfaceConversionClash() throws Exception { runTest("compiler/testData/codegen/box/funInterface/basicFunInterfaceConversionClash.kt"); } + @Test @TestMetadata("castFromAny.kt") public void testCastFromAny() throws Exception { runTest("compiler/testData/codegen/box/funInterface/castFromAny.kt"); } + @Test @TestMetadata("contravariantIntersectionType.kt") public void testContravariantIntersectionType() throws Exception { runTest("compiler/testData/codegen/box/funInterface/contravariantIntersectionType.kt"); } + @Test @TestMetadata("contravariantIntersectionTypeWithNonTrivialCommonSupertype.kt") public void testContravariantIntersectionTypeWithNonTrivialCommonSupertype() throws Exception { runTest("compiler/testData/codegen/box/funInterface/contravariantIntersectionTypeWithNonTrivialCommonSupertype.kt"); } + @Test @TestMetadata("contravariantIntersectionTypeWithNonTrivialCommonSupertype2.kt") public void testContravariantIntersectionTypeWithNonTrivialCommonSupertype2() throws Exception { runTest("compiler/testData/codegen/box/funInterface/contravariantIntersectionTypeWithNonTrivialCommonSupertype2.kt"); } + @Test @TestMetadata("funConversionInVararg.kt") public void testFunConversionInVararg() throws Exception { runTest("compiler/testData/codegen/box/funInterface/funConversionInVararg.kt"); } + @Test @TestMetadata("funInterfaceCallInLambda.kt") public void testFunInterfaceCallInLambda() throws Exception { runTest("compiler/testData/codegen/box/funInterface/funInterfaceCallInLambda.kt"); } + @Test @TestMetadata("funInterfaceInheritance.kt") public void testFunInterfaceInheritance() throws Exception { runTest("compiler/testData/codegen/box/funInterface/funInterfaceInheritance.kt"); } + @Test @TestMetadata("funInterfaceTypealias.kt") public void testFunInterfaceTypealias() throws Exception { runTest("compiler/testData/codegen/box/funInterface/funInterfaceTypealias.kt"); } + @Test @TestMetadata("funInterfaceWithReceiver.kt") public void testFunInterfaceWithReceiver() throws Exception { runTest("compiler/testData/codegen/box/funInterface/funInterfaceWithReceiver.kt"); } + @Test @TestMetadata("inlinedSamWrapper.kt") public void testInlinedSamWrapper() throws Exception { runTest("compiler/testData/codegen/box/funInterface/inlinedSamWrapper.kt"); } + @Test @TestMetadata("intersectionTypeToFunInterfaceConversion.kt") public void testIntersectionTypeToFunInterfaceConversion() throws Exception { runTest("compiler/testData/codegen/box/funInterface/intersectionTypeToFunInterfaceConversion.kt"); } + @Test @TestMetadata("irrelevantPrivateDeclarations.kt") public void testIrrelevantPrivateDeclarations() throws Exception { runTest("compiler/testData/codegen/box/funInterface/irrelevantPrivateDeclarations.kt"); } + @Test @TestMetadata("kt41670.kt") public void testKt41670() throws Exception { runTest("compiler/testData/codegen/box/funInterface/kt41670.kt"); } + @Test @TestMetadata("kt45444_privateFunInterface.kt") public void testKt45444_privateFunInterface() throws Exception { runTest("compiler/testData/codegen/box/funInterface/kt45444_privateFunInterface.kt"); } + @Test @TestMetadata("kt46512_indyFunInterfaceOverCallableReference.kt") public void testKt46512_indyFunInterfaceOverCallableReference() throws Exception { runTest("compiler/testData/codegen/box/funInterface/kt46512_indyFunInterfaceOverCallableReference.kt"); } + @Test @TestMetadata("kt46908_functionSupertype.kt") public void testKt46908_functionSupertype() throws Exception { runTest("compiler/testData/codegen/box/funInterface/kt46908_functionSupertype.kt"); } + @Test @TestMetadata("multimodule.kt") public void testMultimodule() throws Exception { runTest("compiler/testData/codegen/box/funInterface/multimodule.kt"); } + @Test @TestMetadata("noOptimizedCallableReferences.kt") public void testNoOptimizedCallableReferences() throws Exception { runTest("compiler/testData/codegen/box/funInterface/noOptimizedCallableReferences.kt"); } + @Test @TestMetadata("nonAbstractMethod.kt") public void testNonAbstractMethod() throws Exception { runTest("compiler/testData/codegen/box/funInterface/nonAbstractMethod.kt"); } + @Test @TestMetadata("nullableSam.kt") public void testNullableSam() throws Exception { runTest("compiler/testData/codegen/box/funInterface/nullableSam.kt"); } + @Test @TestMetadata("partialSam.kt") public void testPartialSam() throws Exception { runTest("compiler/testData/codegen/box/funInterface/partialSam.kt"); } + @Test @TestMetadata("primitiveConversions.kt") public void testPrimitiveConversions() throws Exception { runTest("compiler/testData/codegen/box/funInterface/primitiveConversions.kt"); } + @Test @TestMetadata("receiverEvaluatedOnce.kt") public void testReceiverEvaluatedOnce() throws Exception { runTest("compiler/testData/codegen/box/funInterface/receiverEvaluatedOnce.kt"); } + @Test @TestMetadata("samConstructorExplicitInvocation.kt") public void testSamConstructorExplicitInvocation() throws Exception { runTest("compiler/testData/codegen/box/funInterface/samConstructorExplicitInvocation.kt"); } + @Test @TestMetadata("samConversionToGenericInterfaceInGenericFun.kt") public void testSamConversionToGenericInterfaceInGenericFun() throws Exception { runTest("compiler/testData/codegen/box/funInterface/samConversionToGenericInterfaceInGenericFun.kt"); } + @Test @TestMetadata("subtypeOfFunctionalTypeToFunInterfaceConversion.kt") public void testSubtypeOfFunctionalTypeToFunInterfaceConversion() throws Exception { runTest("compiler/testData/codegen/box/funInterface/subtypeOfFunctionalTypeToFunInterfaceConversion.kt"); } + @Test @TestMetadata("suspendFunInterfaceConversionCodegen.kt") public void testSuspendFunInterfaceConversionCodegen() throws Exception { runTest("compiler/testData/codegen/box/funInterface/suspendFunInterfaceConversionCodegen.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/funInterface/equality") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Equality extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Equality { + @Test public void testAllFilesPresentInEquality() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface/equality"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("functionReferencesBound.kt") public void testFunctionReferencesBound() throws Exception { runTest("compiler/testData/codegen/box/funInterface/equality/functionReferencesBound.kt"); } + @Test @TestMetadata("functionReferencesUnbound.kt") public void testFunctionReferencesUnbound() throws Exception { runTest("compiler/testData/codegen/box/funInterface/equality/functionReferencesUnbound.kt"); } + @Test @TestMetadata("lambdaRuntimeConversion.kt") public void testLambdaRuntimeConversion() throws Exception { runTest("compiler/testData/codegen/box/funInterface/equality/lambdaRuntimeConversion.kt"); } + @Test @TestMetadata("localFunctionReferences.kt") public void testLocalFunctionReferences() throws Exception { runTest("compiler/testData/codegen/box/funInterface/equality/localFunctionReferences.kt"); } + @Test @TestMetadata("simpleLambdas.kt") public void testSimpleLambdas() throws Exception { runTest("compiler/testData/codegen/box/funInterface/equality/simpleLambdas.kt"); @@ -12391,574 +13934,661 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/functions") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Functions extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Functions { + @Test public void testAllFilesPresentInFunctions() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("coerceVoidToArray.kt") public void testCoerceVoidToArray() throws Exception { runTest("compiler/testData/codegen/box/functions/coerceVoidToArray.kt"); } + @Test @TestMetadata("coerceVoidToObject.kt") public void testCoerceVoidToObject() throws Exception { runTest("compiler/testData/codegen/box/functions/coerceVoidToObject.kt"); } + @Test @TestMetadata("defaultargs.kt") public void testDefaultargs() throws Exception { runTest("compiler/testData/codegen/box/functions/defaultargs.kt"); } + @Test @TestMetadata("defaultargs1.kt") public void testDefaultargs1() throws Exception { runTest("compiler/testData/codegen/box/functions/defaultargs1.kt"); } + @Test @TestMetadata("defaultargs2.kt") public void testDefaultargs2() throws Exception { runTest("compiler/testData/codegen/box/functions/defaultargs2.kt"); } + @Test @TestMetadata("defaultargs3.kt") public void testDefaultargs3() throws Exception { runTest("compiler/testData/codegen/box/functions/defaultargs3.kt"); } + @Test @TestMetadata("defaultargs4.kt") public void testDefaultargs4() throws Exception { runTest("compiler/testData/codegen/box/functions/defaultargs4.kt"); } + @Test @TestMetadata("defaultargs5.kt") public void testDefaultargs5() throws Exception { runTest("compiler/testData/codegen/box/functions/defaultargs5.kt"); } + @Test @TestMetadata("defaultargs6.kt") public void testDefaultargs6() throws Exception { runTest("compiler/testData/codegen/box/functions/defaultargs6.kt"); } + @Test @TestMetadata("defaultargs7.kt") public void testDefaultargs7() throws Exception { runTest("compiler/testData/codegen/box/functions/defaultargs7.kt"); } + @Test @TestMetadata("delegatedPropertyWithMultipleOverriddens_generics.kt") public void testDelegatedPropertyWithMultipleOverriddens_generics() throws Exception { runTest("compiler/testData/codegen/box/functions/delegatedPropertyWithMultipleOverriddens_generics.kt"); } + @Test @TestMetadata("delegatedPropertyWithMultipleOverriddens_noGenerics.kt") public void testDelegatedPropertyWithMultipleOverriddens_noGenerics() throws Exception { runTest("compiler/testData/codegen/box/functions/delegatedPropertyWithMultipleOverriddens_noGenerics.kt"); } + @Test @TestMetadata("ea33909.kt") public void testEa33909() throws Exception { runTest("compiler/testData/codegen/box/functions/ea33909.kt"); } + @Test @TestMetadata("fakeDescriptorWithSeveralOverridenOne.kt") public void testFakeDescriptorWithSeveralOverridenOne() throws Exception { runTest("compiler/testData/codegen/box/functions/fakeDescriptorWithSeveralOverridenOne.kt"); } + @Test @TestMetadata("infixRecursiveCall.kt") public void testInfixRecursiveCall() throws Exception { runTest("compiler/testData/codegen/box/functions/infixRecursiveCall.kt"); } + @Test @TestMetadata("kt1038.kt") public void testKt1038() throws Exception { runTest("compiler/testData/codegen/box/functions/kt1038.kt"); } + @Test @TestMetadata("kt1199.kt") public void testKt1199() throws Exception { runTest("compiler/testData/codegen/box/functions/kt1199.kt"); } + @Test @TestMetadata("kt1413.kt") public void testKt1413() throws Exception { runTest("compiler/testData/codegen/box/functions/kt1413.kt"); } + @Test @TestMetadata("kt1649_1.kt") public void testKt1649_1() throws Exception { runTest("compiler/testData/codegen/box/functions/kt1649_1.kt"); } + @Test @TestMetadata("kt1649_2.kt") public void testKt1649_2() throws Exception { runTest("compiler/testData/codegen/box/functions/kt1649_2.kt"); } + @Test @TestMetadata("kt2270.kt") public void testKt2270() throws Exception { runTest("compiler/testData/codegen/box/functions/kt2270.kt"); } + @Test @TestMetadata("kt2271.kt") public void testKt2271() throws Exception { runTest("compiler/testData/codegen/box/functions/kt2271.kt"); } + @Test @TestMetadata("kt2280.kt") public void testKt2280() throws Exception { runTest("compiler/testData/codegen/box/functions/kt2280.kt"); } + @Test @TestMetadata("kt2481.kt") public void testKt2481() throws Exception { runTest("compiler/testData/codegen/box/functions/kt2481.kt"); } + @Test @TestMetadata("kt2716.kt") public void testKt2716() throws Exception { runTest("compiler/testData/codegen/box/functions/kt2716.kt"); } + @Test @TestMetadata("kt2739.kt") public void testKt2739() throws Exception { runTest("compiler/testData/codegen/box/functions/kt2739.kt"); } + @Test @TestMetadata("kt2929.kt") public void testKt2929() throws Exception { runTest("compiler/testData/codegen/box/functions/kt2929.kt"); } + @Test @TestMetadata("kt3214.kt") public void testKt3214() throws Exception { runTest("compiler/testData/codegen/box/functions/kt3214.kt"); } + @Test @TestMetadata("kt3313.kt") public void testKt3313() throws Exception { runTest("compiler/testData/codegen/box/functions/kt3313.kt"); } + @Test @TestMetadata("kt3573.kt") public void testKt3573() throws Exception { runTest("compiler/testData/codegen/box/functions/kt3573.kt"); } + @Test @TestMetadata("kt3724.kt") public void testKt3724() throws Exception { runTest("compiler/testData/codegen/box/functions/kt3724.kt"); } + @Test @TestMetadata("kt395.kt") public void testKt395() throws Exception { runTest("compiler/testData/codegen/box/functions/kt395.kt"); } + @Test @TestMetadata("kt47449.kt") public void testKt47449() throws Exception { runTest("compiler/testData/codegen/box/functions/kt47449.kt"); } + @Test @TestMetadata("kt47527.kt") public void testKt47527() throws Exception { runTest("compiler/testData/codegen/box/functions/kt47527.kt"); } + @Test @TestMetadata("kt48058.kt") public void testKt48058() throws Exception { runTest("compiler/testData/codegen/box/functions/kt48058.kt"); } + @Test @TestMetadata("kt785.kt") public void testKt785() throws Exception { runTest("compiler/testData/codegen/box/functions/kt785.kt"); } + @Test @TestMetadata("kt873.kt") public void testKt873() throws Exception { runTest("compiler/testData/codegen/box/functions/kt873.kt"); } + @Test @TestMetadata("localFunction.kt") public void testLocalFunction() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunction.kt"); } + @Test @TestMetadata("localReturnInsideFunctionExpression.kt") public void testLocalReturnInsideFunctionExpression() throws Exception { runTest("compiler/testData/codegen/box/functions/localReturnInsideFunctionExpression.kt"); } + @Test @TestMetadata("mutualInline.kt") public void testMutualInline() throws Exception { runTest("compiler/testData/codegen/box/functions/mutualInline.kt"); } + @Test @TestMetadata("nothisnoclosure.kt") public void testNothisnoclosure() throws Exception { runTest("compiler/testData/codegen/box/functions/nothisnoclosure.kt"); } + @Test @TestMetadata("overloadByInterfaceType.kt") public void testOverloadByInterfaceType() throws Exception { runTest("compiler/testData/codegen/box/functions/overloadByInterfaceType.kt"); } + @Test @TestMetadata("prefixRecursiveCall.kt") public void testPrefixRecursiveCall() throws Exception { runTest("compiler/testData/codegen/box/functions/prefixRecursiveCall.kt"); } + @Test @TestMetadata("recursiveCompareTo.kt") public void testRecursiveCompareTo() throws Exception { runTest("compiler/testData/codegen/box/functions/recursiveCompareTo.kt"); } + @Test @TestMetadata("recursiveIncrementCall.kt") public void testRecursiveIncrementCall() throws Exception { runTest("compiler/testData/codegen/box/functions/recursiveIncrementCall.kt"); } + @Test @TestMetadata("typeParameterAsUpperBound.kt") public void testTypeParameterAsUpperBound() throws Exception { runTest("compiler/testData/codegen/box/functions/typeParameterAsUpperBound.kt"); } + @Test @TestMetadata("typeParametersInLocalFunction.kt") public void testTypeParametersInLocalFunction() throws Exception { runTest("compiler/testData/codegen/box/functions/typeParametersInLocalFunction.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/functions/bigArity") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class BigArity extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class BigArity { + @Test public void testAllFilesPresentInBigArity() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/bigArity"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("function255.kt") public void testFunction255() throws Exception { runTest("compiler/testData/codegen/box/functions/bigArity/function255.kt"); } + @Test @TestMetadata("instanceOfCallableReference.kt") public void testInstanceOfCallableReference() throws Exception { runTest("compiler/testData/codegen/box/functions/bigArity/instanceOfCallableReference.kt"); } + @Test @TestMetadata("invokeCallableReference.kt") public void testInvokeCallableReference() throws Exception { runTest("compiler/testData/codegen/box/functions/bigArity/invokeCallableReference.kt"); } + @Test @TestMetadata("invokeLambda.kt") public void testInvokeLambda() throws Exception { runTest("compiler/testData/codegen/box/functions/bigArity/invokeLambda.kt"); } + @Test @TestMetadata("invokeMemberCallableReference.kt") public void testInvokeMemberCallableReference() throws Exception { runTest("compiler/testData/codegen/box/functions/bigArity/invokeMemberCallableReference.kt"); } + @Test @TestMetadata("nestedBigArityFunCalls.kt") public void testNestedBigArityFunCalls() throws Exception { runTest("compiler/testData/codegen/box/functions/bigArity/nestedBigArityFunCalls.kt"); } + @Test @TestMetadata("subclass.kt") public void testSubclass() throws Exception { runTest("compiler/testData/codegen/box/functions/bigArity/subclass.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/functions/functionExpression") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class FunctionExpression extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class FunctionExpression { + @Test public void testAllFilesPresentInFunctionExpression() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/functionExpression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("functionExpression.kt") public void testFunctionExpression() throws Exception { runTest("compiler/testData/codegen/box/functions/functionExpression/functionExpression.kt"); } + @Test @TestMetadata("functionExpressionWithThisReference.kt") public void testFunctionExpressionWithThisReference() throws Exception { runTest("compiler/testData/codegen/box/functions/functionExpression/functionExpressionWithThisReference.kt"); } + @Test @TestMetadata("functionLiteralExpression.kt") public void testFunctionLiteralExpression() throws Exception { runTest("compiler/testData/codegen/box/functions/functionExpression/functionLiteralExpression.kt"); } + @Test @TestMetadata("insideGenericLambda.kt") public void testInsideGenericLambda() throws Exception { runTest("compiler/testData/codegen/box/functions/functionExpression/insideGenericLambda.kt"); } + @Test @TestMetadata("underscoreParameters.kt") public void testUnderscoreParameters() throws Exception { runTest("compiler/testData/codegen/box/functions/functionExpression/underscoreParameters.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/functions/invoke") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Invoke extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Invoke { + @Test public void testAllFilesPresentInInvoke() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/invoke"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("castFunctionToExtension.kt") public void testCastFunctionToExtension() throws Exception { runTest("compiler/testData/codegen/box/functions/invoke/castFunctionToExtension.kt"); } + @Test @TestMetadata("extensionInvokeOnExpr.kt") public void testExtensionInvokeOnExpr() throws Exception { runTest("compiler/testData/codegen/box/functions/invoke/extensionInvokeOnExpr.kt"); } + @Test @TestMetadata("implicitInvokeInCompanionObjectWithFunctionalArgument.kt") public void testImplicitInvokeInCompanionObjectWithFunctionalArgument() throws Exception { runTest("compiler/testData/codegen/box/functions/invoke/implicitInvokeInCompanionObjectWithFunctionalArgument.kt"); } + @Test @TestMetadata("implicitInvokeWithFunctionLiteralArgument.kt") public void testImplicitInvokeWithFunctionLiteralArgument() throws Exception { runTest("compiler/testData/codegen/box/functions/invoke/implicitInvokeWithFunctionLiteralArgument.kt"); } + @Test @TestMetadata("invoke.kt") public void testInvoke() throws Exception { runTest("compiler/testData/codegen/box/functions/invoke/invoke.kt"); } + @Test @TestMetadata("invokeOnExprByConvention.kt") public void testInvokeOnExprByConvention() throws Exception { runTest("compiler/testData/codegen/box/functions/invoke/invokeOnExprByConvention.kt"); } + @Test @TestMetadata("kt3189.kt") public void testKt3189() throws Exception { runTest("compiler/testData/codegen/box/functions/invoke/kt3189.kt"); } + @Test @TestMetadata("kt3190.kt") public void testKt3190() throws Exception { runTest("compiler/testData/codegen/box/functions/invoke/kt3190.kt"); } + @Test @TestMetadata("kt3297.kt") public void testKt3297() throws Exception { runTest("compiler/testData/codegen/box/functions/invoke/kt3297.kt"); } + @Test @TestMetadata("kt3450getAndInvoke.kt") public void testKt3450getAndInvoke() throws Exception { runTest("compiler/testData/codegen/box/functions/invoke/kt3450getAndInvoke.kt"); } + @Test @TestMetadata("kt3631invokeOnString.kt") public void testKt3631invokeOnString() throws Exception { runTest("compiler/testData/codegen/box/functions/invoke/kt3631invokeOnString.kt"); } + @Test @TestMetadata("kt3772.kt") public void testKt3772() throws Exception { runTest("compiler/testData/codegen/box/functions/invoke/kt3772.kt"); } + @Test @TestMetadata("kt3821invokeOnThis.kt") public void testKt3821invokeOnThis() throws Exception { runTest("compiler/testData/codegen/box/functions/invoke/kt3821invokeOnThis.kt"); } + @Test @TestMetadata("kt3822invokeOnThis.kt") public void testKt3822invokeOnThis() throws Exception { runTest("compiler/testData/codegen/box/functions/invoke/kt3822invokeOnThis.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/functions/localFunctions") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class LocalFunctions extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class LocalFunctions { + @Test public void testAllFilesPresentInLocalFunctions() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/localFunctions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("boundTypeParameterInSupertype.kt") public void testBoundTypeParameterInSupertype() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/boundTypeParameterInSupertype.kt"); } + @Test @TestMetadata("boundTypeParameterInVararg.kt") public void testBoundTypeParameterInVararg() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/boundTypeParameterInVararg.kt"); } + @Test @TestMetadata("callBetweenLocalFunctions.kt") public void testCallBetweenLocalFunctions() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/callBetweenLocalFunctions.kt"); } + @Test @TestMetadata("callInlineLocalInLambda.kt") public void testCallInlineLocalInLambda() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/callInlineLocalInLambda.kt"); } + @Test @TestMetadata("captureUpperBoundedTypeParameter.kt") public void testCaptureUpperBoundedTypeParameter() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/captureUpperBoundedTypeParameter.kt"); } + @Test @TestMetadata("definedWithinLambda.kt") public void testDefinedWithinLambda() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/definedWithinLambda.kt"); } + @Test @TestMetadata("definedWithinLambdaInnerUsage1.kt") public void testDefinedWithinLambdaInnerUsage1() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/definedWithinLambdaInnerUsage1.kt"); } + @Test @TestMetadata("definedWithinLambdaInnerUsage2.kt") public void testDefinedWithinLambdaInnerUsage2() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/definedWithinLambdaInnerUsage2.kt"); } + @Test @TestMetadata("kt2895.kt") public void testKt2895() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/kt2895.kt"); } + @Test @TestMetadata("kt3308.kt") public void testKt3308() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/kt3308.kt"); } + @Test @TestMetadata("kt3978.kt") public void testKt3978() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/kt3978.kt"); } + @Test @TestMetadata("kt3978_2.kt") public void testKt3978_2() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/kt3978_2.kt"); } + @Test @TestMetadata("kt4119.kt") public void testKt4119() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/kt4119.kt"); } + @Test @TestMetadata("kt4119_2.kt") public void testKt4119_2() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/kt4119_2.kt"); } + @Test @TestMetadata("kt4514.kt") public void testKt4514() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/kt4514.kt"); } + @Test @TestMetadata("kt4783.kt") public void testKt4783() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/kt4783.kt"); } + @Test @TestMetadata("kt4784.kt") public void testKt4784() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/kt4784.kt"); } + @Test @TestMetadata("kt4989.kt") public void testKt4989() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/kt4989.kt"); } + @Test @TestMetadata("localExtensionOnNullableParameter.kt") public void testLocalExtensionOnNullableParameter() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/localExtensionOnNullableParameter.kt"); } + @Test @TestMetadata("localFunctionInConstructor.kt") public void testLocalFunctionInConstructor() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/localFunctionInConstructor.kt"); } + @Test @TestMetadata("localFunctionVsLocalVariable.kt") public void testLocalFunctionVsLocalVariable() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/localFunctionVsLocalVariable.kt"); } + @Test @TestMetadata("nameClash.kt") public void testNameClash() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/nameClash.kt"); } + @Test @TestMetadata("nameClashAcrossDifferentContainers.kt") public void testNameClashAcrossDifferentContainers() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/nameClashAcrossDifferentContainers.kt"); } + @Test @TestMetadata("overloadedLocalFunWithoutClosure.kt") public void testOverloadedLocalFunWithoutClosure() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunWithoutClosure.kt"); } + @Test @TestMetadata("overloadedLocalFunction.kt") public void testOverloadedLocalFunction() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction.kt"); } + @Test @TestMetadata("overloadedLocalFunction1.kt") public void testOverloadedLocalFunction1() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction1.kt"); } + @Test @TestMetadata("overloadedLocalFunction2.kt") public void testOverloadedLocalFunction2() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction2.kt"); } + @Test @TestMetadata("overloadedLocalFunction3.kt") public void testOverloadedLocalFunction3() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction3.kt"); } + @Test @TestMetadata("parameterAsDefaultValue.kt") public void testParameterAsDefaultValue() throws Exception { runTest("compiler/testData/codegen/box/functions/localFunctions/parameterAsDefaultValue.kt"); @@ -12966,756 +14596,885 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/ieee754") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Ieee754 extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Ieee754 { + @Test public void testAllFilesPresentInIeee754() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ieee754"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("anyCastToPrimitiveCompareTo1.kt") public void testAnyCastToPrimitiveCompareTo1() throws Exception { runTest("compiler/testData/codegen/box/ieee754/anyCastToPrimitiveCompareTo1.kt"); } + @Test @TestMetadata("anyCastToPrimitiveCompareTo2.kt") public void testAnyCastToPrimitiveCompareTo2() throws Exception { runTest("compiler/testData/codegen/box/ieee754/anyCastToPrimitiveCompareTo2.kt"); } + @Test @TestMetadata("anyToReal.kt") public void testAnyToReal() throws Exception { runTest("compiler/testData/codegen/box/ieee754/anyToReal.kt"); } + @Test @TestMetadata("asComparableToDouble.kt") public void testAsComparableToDouble() throws Exception { runTest("compiler/testData/codegen/box/ieee754/asComparableToDouble.kt"); } + @Test @TestMetadata("asComparableToDouble_properIeeeComparisons.kt") public void testAsComparableToDouble_properIeeeComparisons() throws Exception { runTest("compiler/testData/codegen/box/ieee754/asComparableToDouble_properIeeeComparisons.kt"); } + @Test @TestMetadata("comparableToTWithT_properIeeeComparisons.kt") public void testComparableToTWithT_properIeeeComparisons() throws Exception { runTest("compiler/testData/codegen/box/ieee754/comparableToTWithT_properIeeeComparisons.kt"); } + @Test @TestMetadata("comparableTypeCast.kt") public void testComparableTypeCast() throws Exception { runTest("compiler/testData/codegen/box/ieee754/comparableTypeCast.kt"); } + @Test @TestMetadata("dataClass.kt") public void testDataClass() throws Exception { runTest("compiler/testData/codegen/box/ieee754/dataClass.kt"); } + @Test @TestMetadata("differentTypesComparison.kt") public void testDifferentTypesComparison() throws Exception { runTest("compiler/testData/codegen/box/ieee754/differentTypesComparison.kt"); } + @Test @TestMetadata("equalsDouble.kt") public void testEqualsDouble() throws Exception { runTest("compiler/testData/codegen/box/ieee754/equalsDouble.kt"); } + @Test @TestMetadata("equalsDouble_properIeeeComparisons.kt") public void testEqualsDouble_properIeeeComparisons() throws Exception { runTest("compiler/testData/codegen/box/ieee754/equalsDouble_properIeeeComparisons.kt"); } + @Test @TestMetadata("equalsFloat.kt") public void testEqualsFloat() throws Exception { runTest("compiler/testData/codegen/box/ieee754/equalsFloat.kt"); } + @Test @TestMetadata("equalsFloat_properIeeeComparisons.kt") public void testEqualsFloat_properIeeeComparisons() throws Exception { runTest("compiler/testData/codegen/box/ieee754/equalsFloat_properIeeeComparisons.kt"); } + @Test @TestMetadata("equalsNaN.kt") public void testEqualsNaN() throws Exception { runTest("compiler/testData/codegen/box/ieee754/equalsNaN.kt"); } + @Test @TestMetadata("equalsNaN_properIeeeComparisons.kt") public void testEqualsNaN_properIeeeComparisons() throws Exception { runTest("compiler/testData/codegen/box/ieee754/equalsNaN_properIeeeComparisons.kt"); } + @Test @TestMetadata("equalsNullableDouble.kt") public void testEqualsNullableDouble() throws Exception { runTest("compiler/testData/codegen/box/ieee754/equalsNullableDouble.kt"); } + @Test @TestMetadata("equalsNullableDouble_properIeeeComparisons.kt") public void testEqualsNullableDouble_properIeeeComparisons() throws Exception { runTest("compiler/testData/codegen/box/ieee754/equalsNullableDouble_properIeeeComparisons.kt"); } + @Test @TestMetadata("equalsNullableFloat.kt") public void testEqualsNullableFloat() throws Exception { runTest("compiler/testData/codegen/box/ieee754/equalsNullableFloat.kt"); } + @Test @TestMetadata("equalsNullableFloat_properIeeeComparisons.kt") public void testEqualsNullableFloat_properIeeeComparisons() throws Exception { runTest("compiler/testData/codegen/box/ieee754/equalsNullableFloat_properIeeeComparisons.kt"); } + @Test @TestMetadata("explicitCompareCall.kt") public void testExplicitCompareCall() throws Exception { runTest("compiler/testData/codegen/box/ieee754/explicitCompareCall.kt"); } + @Test @TestMetadata("explicitEqualsCall.kt") public void testExplicitEqualsCall() throws Exception { runTest("compiler/testData/codegen/box/ieee754/explicitEqualsCall.kt"); } + @Test @TestMetadata("generic.kt") public void testGeneric() throws Exception { runTest("compiler/testData/codegen/box/ieee754/generic.kt"); } + @Test @TestMetadata("greaterDouble.kt") public void testGreaterDouble() throws Exception { runTest("compiler/testData/codegen/box/ieee754/greaterDouble.kt"); } + @Test @TestMetadata("greaterDouble_properIeeeComparisons.kt") public void testGreaterDouble_properIeeeComparisons() throws Exception { runTest("compiler/testData/codegen/box/ieee754/greaterDouble_properIeeeComparisons.kt"); } + @Test @TestMetadata("greaterFloat.kt") public void testGreaterFloat() throws Exception { runTest("compiler/testData/codegen/box/ieee754/greaterFloat.kt"); } + @Test @TestMetadata("greaterFloat_properIeeeComparisons.kt") public void testGreaterFloat_properIeeeComparisons() throws Exception { runTest("compiler/testData/codegen/box/ieee754/greaterFloat_properIeeeComparisons.kt"); } + @Test @TestMetadata("inline.kt") public void testInline() throws Exception { runTest("compiler/testData/codegen/box/ieee754/inline.kt"); } + @Test @TestMetadata("lessDouble.kt") public void testLessDouble() throws Exception { runTest("compiler/testData/codegen/box/ieee754/lessDouble.kt"); } + @Test @TestMetadata("lessDouble_properIeeeAndNewInference.kt") public void testLessDouble_properIeeeAndNewInference() throws Exception { runTest("compiler/testData/codegen/box/ieee754/lessDouble_properIeeeAndNewInference.kt"); } + @Test @TestMetadata("lessDouble_properIeeeComparisons.kt") public void testLessDouble_properIeeeComparisons() throws Exception { runTest("compiler/testData/codegen/box/ieee754/lessDouble_properIeeeComparisons.kt"); } + @Test @TestMetadata("lessFloat.kt") public void testLessFloat() throws Exception { runTest("compiler/testData/codegen/box/ieee754/lessFloat.kt"); } + @Test @TestMetadata("lessFloat_properIeeeComparisons.kt") public void testLessFloat_properIeeeComparisons() throws Exception { runTest("compiler/testData/codegen/box/ieee754/lessFloat_properIeeeComparisons.kt"); } + @Test @TestMetadata("nullableAnyToReal.kt") public void testNullableAnyToReal() throws Exception { runTest("compiler/testData/codegen/box/ieee754/nullableAnyToReal.kt"); } + @Test @TestMetadata("nullableDoubleEquals.kt") public void testNullableDoubleEquals() throws Exception { runTest("compiler/testData/codegen/box/ieee754/nullableDoubleEquals.kt"); } + @Test @TestMetadata("nullableDoubleEqualsLV13.kt") public void testNullableDoubleEqualsLV13() throws Exception { runTest("compiler/testData/codegen/box/ieee754/nullableDoubleEqualsLV13.kt"); } + @Test @TestMetadata("nullableDoubleNotEquals.kt") public void testNullableDoubleNotEquals() throws Exception { runTest("compiler/testData/codegen/box/ieee754/nullableDoubleNotEquals.kt"); } + @Test @TestMetadata("nullableFloatEquals.kt") public void testNullableFloatEquals() throws Exception { runTest("compiler/testData/codegen/box/ieee754/nullableFloatEquals.kt"); } + @Test @TestMetadata("nullableFloatNotEquals.kt") public void testNullableFloatNotEquals() throws Exception { runTest("compiler/testData/codegen/box/ieee754/nullableFloatNotEquals.kt"); } + @Test @TestMetadata("nullableIntEquals.kt") public void testNullableIntEquals() throws Exception { runTest("compiler/testData/codegen/box/ieee754/nullableIntEquals.kt"); } + @Test @TestMetadata("safeCall.kt") public void testSafeCall() throws Exception { runTest("compiler/testData/codegen/box/ieee754/safeCall.kt"); } + @Test @TestMetadata("smartCastOnWhenSubjectAfterCheckInBranch_properIeeeComparisons.kt") public void testSmartCastOnWhenSubjectAfterCheckInBranch_properIeeeComparisons() throws Exception { runTest("compiler/testData/codegen/box/ieee754/smartCastOnWhenSubjectAfterCheckInBranch_properIeeeComparisons.kt"); } + @Test @TestMetadata("smartCastToDifferentTypesWithNumericPromotion_properIeeeComparisons.kt") public void testSmartCastToDifferentTypesWithNumericPromotion_properIeeeComparisons() throws Exception { runTest("compiler/testData/codegen/box/ieee754/smartCastToDifferentTypesWithNumericPromotion_properIeeeComparisons.kt"); } + @Test @TestMetadata("smartCastToDifferentTypes_properIeeeComparisons.kt") public void testSmartCastToDifferentTypes_properIeeeComparisons() throws Exception { runTest("compiler/testData/codegen/box/ieee754/smartCastToDifferentTypes_properIeeeComparisons.kt"); } + @Test @TestMetadata("smartCastToDoubleAndComparableToDouble.kt") public void testSmartCastToDoubleAndComparableToDouble() throws Exception { runTest("compiler/testData/codegen/box/ieee754/smartCastToDoubleAndComparableToDouble.kt"); } + @Test @TestMetadata("smartCastToInt.kt") public void testSmartCastToInt() throws Exception { runTest("compiler/testData/codegen/box/ieee754/smartCastToInt.kt"); } + @Test @TestMetadata("when.kt") public void testWhen() throws Exception { runTest("compiler/testData/codegen/box/ieee754/when.kt"); } + @Test @TestMetadata("whenNoSubject.kt") public void testWhenNoSubject() throws Exception { runTest("compiler/testData/codegen/box/ieee754/whenNoSubject.kt"); } + @Test @TestMetadata("whenNoSubject_properIeeeComparisons.kt") public void testWhenNoSubject_properIeeeComparisons() throws Exception { runTest("compiler/testData/codegen/box/ieee754/whenNoSubject_properIeeeComparisons.kt"); } + @Test @TestMetadata("whenNullableSmartCast.kt") public void testWhenNullableSmartCast() throws Exception { runTest("compiler/testData/codegen/box/ieee754/whenNullableSmartCast.kt"); } + @Test @TestMetadata("when_properIeeeComparisons.kt") public void testWhen_properIeeeComparisons() throws Exception { runTest("compiler/testData/codegen/box/ieee754/when_properIeeeComparisons.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/increment") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Increment extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Increment { + @Test public void testAllFilesPresentInIncrement() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/increment"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("argumentWithSideEffects.kt") public void testArgumentWithSideEffects() throws Exception { runTest("compiler/testData/codegen/box/increment/argumentWithSideEffects.kt"); } + @Test @TestMetadata("arrayElement.kt") public void testArrayElement() throws Exception { runTest("compiler/testData/codegen/box/increment/arrayElement.kt"); } + @Test @TestMetadata("assignPlusOnSmartCast.kt") public void testAssignPlusOnSmartCast() throws Exception { runTest("compiler/testData/codegen/box/increment/assignPlusOnSmartCast.kt"); } + @Test @TestMetadata("augmentedAssignmentWithComplexRhs.kt") public void testAugmentedAssignmentWithComplexRhs() throws Exception { runTest("compiler/testData/codegen/box/increment/augmentedAssignmentWithComplexRhs.kt"); } + @Test @TestMetadata("classNaryGetSet.kt") public void testClassNaryGetSet() throws Exception { runTest("compiler/testData/codegen/box/increment/classNaryGetSet.kt"); } + @Test @TestMetadata("classVarargGetSet.kt") public void testClassVarargGetSet() throws Exception { runTest("compiler/testData/codegen/box/increment/classVarargGetSet.kt"); } + @Test @TestMetadata("classVarargGetSetEvaluationOrder.kt") public void testClassVarargGetSetEvaluationOrder() throws Exception { runTest("compiler/testData/codegen/box/increment/classVarargGetSetEvaluationOrder.kt"); } + @Test @TestMetadata("classWithGetSet.kt") public void testClassWithGetSet() throws Exception { runTest("compiler/testData/codegen/box/increment/classWithGetSet.kt"); } + @Test @TestMetadata("extOnLong.kt") public void testExtOnLong() throws Exception { runTest("compiler/testData/codegen/box/increment/extOnLong.kt"); } + @Test @TestMetadata("genericClassWithGetSet.kt") public void testGenericClassWithGetSet() throws Exception { runTest("compiler/testData/codegen/box/increment/genericClassWithGetSet.kt"); } + @Test @TestMetadata("kt36956.kt") public void testKt36956() throws Exception { runTest("compiler/testData/codegen/box/increment/kt36956.kt"); } + @Test @TestMetadata("memberExtOnLong.kt") public void testMemberExtOnLong() throws Exception { runTest("compiler/testData/codegen/box/increment/memberExtOnLong.kt"); } + @Test @TestMetadata("mutableListElement.kt") public void testMutableListElement() throws Exception { runTest("compiler/testData/codegen/box/increment/mutableListElement.kt"); } + @Test @TestMetadata("nullable.kt") public void testNullable() throws Exception { runTest("compiler/testData/codegen/box/increment/nullable.kt"); } + @Test @TestMetadata("postfixIncrementDoubleSmartCast.kt") public void testPostfixIncrementDoubleSmartCast() throws Exception { runTest("compiler/testData/codegen/box/increment/postfixIncrementDoubleSmartCast.kt"); } + @Test @TestMetadata("postfixIncrementOnClass.kt") public void testPostfixIncrementOnClass() throws Exception { runTest("compiler/testData/codegen/box/increment/postfixIncrementOnClass.kt"); } + @Test @TestMetadata("postfixIncrementOnClassSmartCast.kt") public void testPostfixIncrementOnClassSmartCast() throws Exception { runTest("compiler/testData/codegen/box/increment/postfixIncrementOnClassSmartCast.kt"); } + @Test @TestMetadata("postfixIncrementOnShortSmartCast.kt") public void testPostfixIncrementOnShortSmartCast() throws Exception { runTest("compiler/testData/codegen/box/increment/postfixIncrementOnShortSmartCast.kt"); } + @Test @TestMetadata("postfixIncrementOnSmartCast.kt") public void testPostfixIncrementOnSmartCast() throws Exception { runTest("compiler/testData/codegen/box/increment/postfixIncrementOnSmartCast.kt"); } + @Test @TestMetadata("postfixNullableClassIncrement.kt") public void testPostfixNullableClassIncrement() throws Exception { runTest("compiler/testData/codegen/box/increment/postfixNullableClassIncrement.kt"); } + @Test @TestMetadata("postfixNullableIncrement.kt") public void testPostfixNullableIncrement() throws Exception { runTest("compiler/testData/codegen/box/increment/postfixNullableIncrement.kt"); } + @Test @TestMetadata("prefixIncrementOnClass.kt") public void testPrefixIncrementOnClass() throws Exception { runTest("compiler/testData/codegen/box/increment/prefixIncrementOnClass.kt"); } + @Test @TestMetadata("prefixIncrementOnClassSmartCast.kt") public void testPrefixIncrementOnClassSmartCast() throws Exception { runTest("compiler/testData/codegen/box/increment/prefixIncrementOnClassSmartCast.kt"); } + @Test @TestMetadata("prefixIncrementOnSmartCast.kt") public void testPrefixIncrementOnSmartCast() throws Exception { runTest("compiler/testData/codegen/box/increment/prefixIncrementOnSmartCast.kt"); } + @Test @TestMetadata("prefixNullableClassIncrement.kt") public void testPrefixNullableClassIncrement() throws Exception { runTest("compiler/testData/codegen/box/increment/prefixNullableClassIncrement.kt"); } + @Test @TestMetadata("prefixNullableIncrement.kt") public void testPrefixNullableIncrement() throws Exception { runTest("compiler/testData/codegen/box/increment/prefixNullableIncrement.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/inference") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Inference extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Inference { + @Test public void testAllFilesPresentInInference() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("approximateNonTopLevelCapturedTypes.kt") public void testApproximateNonTopLevelCapturedTypes() throws Exception { runTest("compiler/testData/codegen/box/inference/approximateNonTopLevelCapturedTypes.kt"); } + @Test @TestMetadata("builderInferenceLeakingVariable.kt") public void testBuilderInferenceLeakingVariable() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInferenceLeakingVariable.kt"); } + @Test @TestMetadata("capturedStarProjection.kt") public void testCapturedStarProjection() throws Exception { runTest("compiler/testData/codegen/box/inference/capturedStarProjection.kt"); } + @Test @TestMetadata("capturedTypesSubstitutionIntoAbbreviation.kt") public void testCapturedTypesSubstitutionIntoAbbreviation() throws Exception { runTest("compiler/testData/codegen/box/inference/capturedTypesSubstitutionIntoAbbreviation.kt"); } + @Test @TestMetadata("coercionToUnitWithLastLambdaExpression.kt") public void testCoercionToUnitWithLastLambdaExpression() throws Exception { runTest("compiler/testData/codegen/box/inference/coercionToUnitWithLastLambdaExpression.kt"); } + @Test @TestMetadata("coerctionToUnitForLastExpressionWithStarProjection.kt") public void testCoerctionToUnitForLastExpressionWithStarProjection() throws Exception { runTest("compiler/testData/codegen/box/inference/coerctionToUnitForLastExpressionWithStarProjection.kt"); } + @Test @TestMetadata("earlyReturnInsideCrossinlineLambda.kt") public void testEarlyReturnInsideCrossinlineLambda() throws Exception { runTest("compiler/testData/codegen/box/inference/earlyReturnInsideCrossinlineLambda.kt"); } + @Test @TestMetadata("inferenceWithTypeVariableInsideCapturedType.kt") public void testInferenceWithTypeVariableInsideCapturedType() throws Exception { runTest("compiler/testData/codegen/box/inference/inferenceWithTypeVariableInsideCapturedType.kt"); } + @Test @TestMetadata("integerLiteralTypeInLamdaReturnType.kt") public void testIntegerLiteralTypeInLamdaReturnType() throws Exception { runTest("compiler/testData/codegen/box/inference/integerLiteralTypeInLamdaReturnType.kt"); } + @Test @TestMetadata("kt10822.kt") public void testKt10822() throws Exception { runTest("compiler/testData/codegen/box/inference/kt10822.kt"); } + @Test @TestMetadata("kt35684.kt") public void testKt35684() throws Exception { runTest("compiler/testData/codegen/box/inference/kt35684.kt"); } + @Test @TestMetadata("kt36446.kt") public void testKt36446() throws Exception { runTest("compiler/testData/codegen/box/inference/kt36446.kt"); } + @Test @TestMetadata("kt38664.kt") public void testKt38664() throws Exception { runTest("compiler/testData/codegen/box/inference/kt38664.kt"); } + @Test @TestMetadata("kt39824.kt") public void testKt39824() throws Exception { runTest("compiler/testData/codegen/box/inference/kt39824.kt"); } + @Test @TestMetadata("kt42042.kt") public void testKt42042() throws Exception { runTest("compiler/testData/codegen/box/inference/kt42042.kt"); } + @Test @TestMetadata("kt42130.kt") public void testKt42130() throws Exception { runTest("compiler/testData/codegen/box/inference/kt42130.kt"); } + @Test @TestMetadata("kt45118.kt") public void testKt45118() throws Exception { runTest("compiler/testData/codegen/box/inference/kt45118.kt"); } + @Test @TestMetadata("kt49838.kt") public void testKt49838() throws Exception { runTest("compiler/testData/codegen/box/inference/kt49838.kt"); } + @Test @TestMetadata("lambdaWithStarReturn.kt") public void testLambdaWithStarReturn() throws Exception { runTest("compiler/testData/codegen/box/inference/lambdaWithStarReturn.kt"); } + @Test @TestMetadata("lambdasWithExtensionFunctionType.kt") public void testLambdasWithExtensionFunctionType() throws Exception { runTest("compiler/testData/codegen/box/inference/lambdasWithExtensionFunctionType.kt"); } + @Test @TestMetadata("lastExpressionOfLambdaWithNothingConstraint.kt") public void testLastExpressionOfLambdaWithNothingConstraint() throws Exception { runTest("compiler/testData/codegen/box/inference/lastExpressionOfLambdaWithNothingConstraint.kt"); } + @Test @TestMetadata("mapCollectChainWithNullResult.kt") public void testMapCollectChainWithNullResult() throws Exception { runTest("compiler/testData/codegen/box/inference/mapCollectChainWithNullResult.kt"); } + @Test @TestMetadata("noCoercionToUniForNullableLambdaReturnType.kt") public void testNoCoercionToUniForNullableLambdaReturnType() throws Exception { runTest("compiler/testData/codegen/box/inference/noCoercionToUniForNullableLambdaReturnType.kt"); } + @Test @TestMetadata("noCoercionToUnitWithEqualityConstraintForNullableReturnType.kt") public void testNoCoercionToUnitWithEqualityConstraintForNullableReturnType() throws Exception { runTest("compiler/testData/codegen/box/inference/noCoercionToUnitWithEqualityConstraintForNullableReturnType.kt"); } + @Test @TestMetadata("overrideDefaultProperty.kt") public void testOverrideDefaultProperty() throws Exception { runTest("compiler/testData/codegen/box/inference/overrideDefaultProperty.kt"); } + @Test @TestMetadata("overrideGenericDefaultMethod.kt") public void testOverrideGenericDefaultMethod() throws Exception { runTest("compiler/testData/codegen/box/inference/overrideGenericDefaultMethod.kt"); } + @Test @TestMetadata("plusAssignInsideLambda.kt") public void testPlusAssignInsideLambda() throws Exception { runTest("compiler/testData/codegen/box/inference/plusAssignInsideLambda.kt"); } + @Test @TestMetadata("recursiveConstraintInsideTypeArgumentWithStarProjection.kt") public void testRecursiveConstraintInsideTypeArgumentWithStarProjection() throws Exception { runTest("compiler/testData/codegen/box/inference/recursiveConstraintInsideTypeArgumentWithStarProjection.kt"); } + @Test @TestMetadata("referenceToCatchParameterFromLambdaExpression.kt") public void testReferenceToCatchParameterFromLambdaExpression() throws Exception { runTest("compiler/testData/codegen/box/inference/referenceToCatchParameterFromLambdaExpression.kt"); } + @Test @TestMetadata("specialCallsWithCallableReferences.kt") public void testSpecialCallsWithCallableReferences() throws Exception { runTest("compiler/testData/codegen/box/inference/specialCallsWithCallableReferences.kt"); } + @Test @TestMetadata("sumOfOverloads.kt") public void testSumOfOverloads() throws Exception { runTest("compiler/testData/codegen/box/inference/sumOfOverloads.kt"); } + @Test @TestMetadata("suspendExtensionRecevierFromConstraint.kt") public void testSuspendExtensionRecevierFromConstraint() throws Exception { runTest("compiler/testData/codegen/box/inference/suspendExtensionRecevierFromConstraint.kt"); } + @Test @TestMetadata("unsafeVarianceCodegen.kt") public void testUnsafeVarianceCodegen() throws Exception { runTest("compiler/testData/codegen/box/inference/unsafeVarianceCodegen.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/inference/builderInference") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class BuilderInference extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class BuilderInference { + @Test public void testAllFilesPresentInBuilderInference() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inference/builderInference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("builderCallAsReturnTypeInLocalClass.kt") public void testBuilderCallAsReturnTypeInLocalClass() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/builderCallAsReturnTypeInLocalClass.kt"); } + @Test @TestMetadata("callableReferenceAndCoercionToUnit.kt") public void testCallableReferenceAndCoercionToUnit() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/callableReferenceAndCoercionToUnit.kt"); } + @Test @TestMetadata("callableReferencesProperCompletion.kt") public void testCallableReferencesProperCompletion() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/callableReferencesProperCompletion.kt"); } + @Test @TestMetadata("capturedTypes.kt") public void testCapturedTypes() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/capturedTypes.kt"); } + @Test @TestMetadata("changingResolveIfDontUseBuilderInferenceDisabledFeature.kt") public void testChangingResolveIfDontUseBuilderInferenceDisabledFeature() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/changingResolveIfDontUseBuilderInferenceDisabledFeature.kt"); } + @Test @TestMetadata("constraintsBetweenTwoStubVariables.kt") public void testConstraintsBetweenTwoStubVariables() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/constraintsBetweenTwoStubVariables.kt"); } + @Test @TestMetadata("kt41164.kt") public void testKt41164() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/kt41164.kt"); } + @Test @TestMetadata("kt42139.kt") public void testKt42139() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/kt42139.kt"); } + @Test @TestMetadata("kt44241.kt") public void testKt44241() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/kt44241.kt"); } + @Test @TestMetadata("kt45083.kt") public void testKt45083() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/kt45083.kt"); } + @Test @TestMetadata("kt47052.kt") public void testKt47052() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/kt47052.kt"); } + @Test @TestMetadata("kt47744.kt") public void testKt47744() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/kt47744.kt"); } + @Test @TestMetadata("kt49887.kt") public void testKt49887() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/kt49887.kt"); } + @Test @TestMetadata("kt51988.kt") public void testKt51988() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/kt51988.kt"); } + @Test @TestMetadata("labaledCall.kt") public void testLabaledCall() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/labaledCall.kt"); } + @Test @TestMetadata("lackOfNullCheckOnNullableInsideBuild.kt") public void testLackOfNullCheckOnNullableInsideBuild() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/lackOfNullCheckOnNullableInsideBuild.kt"); } + @Test @TestMetadata("memberScope.kt") public void testMemberScope() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/memberScope.kt"); } + @Test @TestMetadata("nullability.kt") public void testNullability() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/nullability.kt"); } + @Test @TestMetadata("propagateInferenceSessionIntoDeclarationAnalyzers.kt") public void testPropagateInferenceSessionIntoDeclarationAnalyzers() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/propagateInferenceSessionIntoDeclarationAnalyzers.kt"); } + @Test @TestMetadata("specialCallsWithCallableReferences.kt") public void testSpecialCallsWithCallableReferences() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferences.kt"); } + @Test @TestMetadata("specialCallsWithCallableReferencesDontRewriteAtSlice.kt") public void testSpecialCallsWithCallableReferencesDontRewriteAtSlice() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontRewriteAtSlice.kt"); } + @Test @TestMetadata("specialCallsWithCallableReferencesErrorType.kt") public void testSpecialCallsWithCallableReferencesErrorType() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesErrorType.kt"); } + @Test @TestMetadata("specialCallsWithLambdas.kt") public void testSpecialCallsWithLambdas() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithLambdas.kt"); } + @Test @TestMetadata("substituteStubTypeIntoCR.kt") public void testSubstituteStubTypeIntoCR() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/substituteStubTypeIntoCR.kt"); } + @Test @TestMetadata("substituteStubTypeIntolambdaParameterDescriptor.kt") public void testSubstituteStubTypeIntolambdaParameterDescriptor() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/substituteStubTypeIntolambdaParameterDescriptor.kt"); } + @Test @TestMetadata("substitutelambdaExtensionReceiverType.kt") public void testSubstitutelambdaExtensionReceiverType() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/substitutelambdaExtensionReceiverType.kt"); } + @Test @TestMetadata("topDownCompletionBreakedByNonBuilderInferenceSession.kt") public void testTopDownCompletionBreakedByNonBuilderInferenceSession() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/topDownCompletionBreakedByNonBuilderInferenceSession.kt"); } + @Test @TestMetadata("topDownCompletionWithThreeBuilderInferenceCalls.kt") public void testTopDownCompletionWithThreeBuilderInferenceCalls() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/topDownCompletionWithThreeBuilderInferenceCalls.kt"); } + @Test @TestMetadata("topDownCompletionWithThreeBuilderInferenceCallsSameLevel.kt") public void testTopDownCompletionWithThreeBuilderInferenceCallsSameLevel() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/topDownCompletionWithThreeBuilderInferenceCallsSameLevel.kt"); } + @Test @TestMetadata("topDownCompletionWithTwoBuilderInferenceCalls.kt") public void testTopDownCompletionWithTwoBuilderInferenceCalls() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/topDownCompletionWithTwoBuilderInferenceCalls.kt"); } + @Test @TestMetadata("withExpectedType.kt") public void testWithExpectedType() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/withExpectedType.kt"); } + @Test @TestMetadata("withoutAnnotation.kt") public void testWithoutAnnotation() throws Exception { runTest("compiler/testData/codegen/box/inference/builderInference/withoutAnnotation.kt"); @@ -13723,2641 +15482,3112 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineArgsInPlace") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class InlineArgsInPlace extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class InlineArgsInPlace { + @Test public void testAllFilesPresentInInlineArgsInPlace() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineArgsInPlace"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("arrayDequeRemoveAll.kt") public void testArrayDequeRemoveAll() throws Exception { runTest("compiler/testData/codegen/box/inlineArgsInPlace/arrayDequeRemoveAll.kt"); } + @Test @TestMetadata("breakInArgumentExpression.kt") public void testBreakInArgumentExpression() throws Exception { runTest("compiler/testData/codegen/box/inlineArgsInPlace/breakInArgumentExpression.kt"); } + @Test @TestMetadata("continueInArgumentExpression.kt") public void testContinueInArgumentExpression() throws Exception { runTest("compiler/testData/codegen/box/inlineArgsInPlace/continueInArgumentExpression.kt"); } + @Test @TestMetadata("inlineCircularDedepency.kt") public void testInlineCircularDedepency() throws Exception { runTest("compiler/testData/codegen/box/inlineArgsInPlace/inlineCircularDedepency.kt"); } + @Test @TestMetadata("kotlinReflect.kt") public void testKotlinReflect() throws Exception { runTest("compiler/testData/codegen/box/inlineArgsInPlace/kotlinReflect.kt"); } + @Test @TestMetadata("kt49370.kt") public void testKt49370() throws Exception { runTest("compiler/testData/codegen/box/inlineArgsInPlace/kt49370.kt"); } + @Test @TestMetadata("kt49407.kt") public void testKt49407() throws Exception { runTest("compiler/testData/codegen/box/inlineArgsInPlace/kt49407.kt"); } + @Test @TestMetadata("mapSet.kt") public void testMapSet() throws Exception { runTest("compiler/testData/codegen/box/inlineArgsInPlace/mapSet.kt"); } + @Test @TestMetadata("mutableCollectionPlusAssign.kt") public void testMutableCollectionPlusAssign() throws Exception { runTest("compiler/testData/codegen/box/inlineArgsInPlace/mutableCollectionPlusAssign.kt"); } + @Test @TestMetadata("noinlineParameter.kt") public void testNoinlineParameter() throws Exception { runTest("compiler/testData/codegen/box/inlineArgsInPlace/noinlineParameter.kt"); } + @Test @TestMetadata("suspensionPointInsideArgument.kt") public void testSuspensionPointInsideArgument() throws Exception { runTest("compiler/testData/codegen/box/inlineArgsInPlace/suspensionPointInsideArgument.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class InlineClasses extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - - private void runTest(String testDataFilePath, java.util.function.Function transformer) throws Exception { - KotlinTestUtils.runTest0(path -> doTestWithTransformer(path, transformer), TargetBackend.WASM, testDataFilePath); - } - + public class InlineClasses { + @Test public void testAllFilesPresentInInlineClasses() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("annotatedMemberExtensionProperty.kt") public void testAnnotatedMemberExtensionProperty() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/annotatedMemberExtensionProperty.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("annotatedMemberExtensionPropertyGeneric.kt") public void testAnnotatedMemberExtensionPropertyGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/annotatedMemberExtensionPropertyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("anySuperCall.kt") public void testAnySuperCall() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/anySuperCall.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("anySuperCallGeneric.kt") public void testAnySuperCallGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/anySuperCallGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boundCallableReferencePassedToInlineFunction.kt") public void testBoundCallableReferencePassedToInlineFunction() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boundCallableReferencePassedToInlineFunction.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boundCallableReferencePassedToInlineFunctionGeneric.kt") public void testBoundCallableReferencePassedToInlineFunctionGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boundCallableReferencePassedToInlineFunctionGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boundCallableReferencePassedToInlineFunctionGeneric2.kt") public void testBoundCallableReferencePassedToInlineFunctionGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boundCallableReferencePassedToInlineFunctionGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxImplDoesNotExecuteInSecondaryConstructor.kt") public void testBoxImplDoesNotExecuteInSecondaryConstructor() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxImplDoesNotExecuteInSecondaryConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxImplDoesNotExecuteInSecondaryConstructorGeneric.kt") public void testBoxImplDoesNotExecuteInSecondaryConstructorGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxImplDoesNotExecuteInSecondaryConstructorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxImplDoesNotExecuteInitBlock.kt") public void testBoxImplDoesNotExecuteInitBlock() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxImplDoesNotExecuteInitBlock.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxImplDoesNotExecuteInitBlockGeneric.kt") public void testBoxImplDoesNotExecuteInitBlockGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxImplDoesNotExecuteInitBlockGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableForFakeOverride.kt") public void testBoxNullableForFakeOverride() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxNullableForFakeOverride.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableForFakeOverrideGeneric.kt") public void testBoxNullableForFakeOverrideGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxNullableForFakeOverrideGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableForFakeOverrideGeneric2.kt") public void testBoxNullableForFakeOverrideGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxNullableForFakeOverrideGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableValueOfInlineClassWithNonNullUnderlyingType.kt") public void testBoxNullableValueOfInlineClassWithNonNullUnderlyingType() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxNullableValueOfInlineClassWithNonNullUnderlyingType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableValueOfInlineClassWithNonNullUnderlyingTypeGeneric.kt") public void testBoxNullableValueOfInlineClassWithNonNullUnderlyingTypeGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxNullableValueOfInlineClassWithNonNullUnderlyingTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableValueOfInlineClassWithNonNullUnderlyingTypeGeneric2.kt") public void testBoxNullableValueOfInlineClassWithNonNullUnderlyingTypeGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxNullableValueOfInlineClassWithNonNullUnderlyingTypeGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableValueOfInlineClassWithPrimitiveUnderlyingType.kt") public void testBoxNullableValueOfInlineClassWithPrimitiveUnderlyingType() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxNullableValueOfInlineClassWithPrimitiveUnderlyingType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableValueOfInlineClassWithPrimitiveUnderlyingTypeGeneric.kt") public void testBoxNullableValueOfInlineClassWithPrimitiveUnderlyingTypeGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxNullableValueOfInlineClassWithPrimitiveUnderlyingTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableValueOfInlineClassWithPrimitiveUnderlyingTypeGeneric2.kt") public void testBoxNullableValueOfInlineClassWithPrimitiveUnderlyingTypeGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxNullableValueOfInlineClassWithPrimitiveUnderlyingTypeGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxResultInlineClassOfConstructorCall.kt") public void testBoxResultInlineClassOfConstructorCall() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxResultInlineClassOfConstructorCall.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxResultInlineClassOfConstructorCallGeneric.kt") public void testBoxResultInlineClassOfConstructorCallGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxResultInlineClassOfConstructorCallGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxResultInlineClassOfConstructorCallGeneric2.kt") public void testBoxResultInlineClassOfConstructorCallGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxResultInlineClassOfConstructorCallGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxUnboxInlineClassesWithOperatorsGetSet.kt") public void testBoxUnboxInlineClassesWithOperatorsGetSet() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxUnboxInlineClassesWithOperatorsGetSet.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxUnboxInlineClassesWithOperatorsGetSetGeneric.kt") public void testBoxUnboxInlineClassesWithOperatorsGetSetGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxUnboxInlineClassesWithOperatorsGetSetGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxUnboxOfInlineClassForCapturedVars.kt") public void testBoxUnboxOfInlineClassForCapturedVars() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxUnboxOfInlineClassForCapturedVars.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxUnboxOfInlineClassForCapturedVarsGeneric.kt") public void testBoxUnboxOfInlineClassForCapturedVarsGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxUnboxOfInlineClassForCapturedVarsGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("bridgeForFunctionReturningInlineClass.kt") public void testBridgeForFunctionReturningInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/bridgeForFunctionReturningInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("bridgeForFunctionReturningInlineClassGeneric.kt") public void testBridgeForFunctionReturningInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/bridgeForFunctionReturningInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("bridgeGenerationWithInlineClassOverAny.kt") public void testBridgeGenerationWithInlineClassOverAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/bridgeGenerationWithInlineClassOverAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("bridgeGenerationWithInlineClassOverAnyGeneric.kt") public void testBridgeGenerationWithInlineClassOverAnyGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/bridgeGenerationWithInlineClassOverAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("bridgeGenerationWithInlineClassOverAnyGeneric2.kt") public void testBridgeGenerationWithInlineClassOverAnyGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/bridgeGenerationWithInlineClassOverAnyGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("bridgesWhenInlineClassImplementsGenericInterface.kt") public void testBridgesWhenInlineClassImplementsGenericInterface() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/bridgesWhenInlineClassImplementsGenericInterface.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("bridgesWhenInlineClassImplementsGenericInterfaceGeneric.kt") public void testBridgesWhenInlineClassImplementsGenericInterfaceGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/bridgesWhenInlineClassImplementsGenericInterfaceGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("callComputablePropertyInsideInlineClass.kt") public void testCallComputablePropertyInsideInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callComputablePropertyInsideInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("callableReferencesWithInlineClasses.kt") public void testCallableReferencesWithInlineClasses() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferencesWithInlineClasses.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("callableReferencesWithInlineClassesGeneric.kt") public void testCallableReferencesWithInlineClassesGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferencesWithInlineClassesGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("castInsideWhenExpression.kt") public void testCastInsideWhenExpression() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/castInsideWhenExpression.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("castInsideWhenExpressionGeneric.kt") public void testCastInsideWhenExpressionGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/castInsideWhenExpressionGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkBoxUnboxOfArgumentsOnInlinedFunctions.kt") public void testCheckBoxUnboxOfArgumentsOnInlinedFunctions() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkBoxUnboxOfArgumentsOnInlinedFunctions.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkBoxUnboxOfArgumentsOnInlinedFunctionsGeneric.kt") public void testCheckBoxUnboxOfArgumentsOnInlinedFunctionsGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkBoxUnboxOfArgumentsOnInlinedFunctionsGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkBoxingAfterAssertionOperator.kt") public void testCheckBoxingAfterAssertionOperator() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingAfterAssertionOperator.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkBoxingAfterAssertionOperatorGeneric.kt") public void testCheckBoxingAfterAssertionOperatorGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingAfterAssertionOperatorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkBoxingForComplexClassHierarchy.kt") public void testCheckBoxingForComplexClassHierarchy() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingForComplexClassHierarchy.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkBoxingForComplexClassHierarchyGeneric.kt") public void testCheckBoxingForComplexClassHierarchyGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingForComplexClassHierarchyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkBoxingForNonLocalAndLabeledReturns.kt") public void testCheckBoxingForNonLocalAndLabeledReturns() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingForNonLocalAndLabeledReturns.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkBoxingForNonLocalAndLabeledReturnsGeneric.kt") public void testCheckBoxingForNonLocalAndLabeledReturnsGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingForNonLocalAndLabeledReturnsGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkBoxingFromReturnTypeForInlineClasses.kt") public void testCheckBoxingFromReturnTypeForInlineClasses() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingFromReturnTypeForInlineClasses.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkBoxingFromReturnTypeForInlineClassesGeneric.kt") public void testCheckBoxingFromReturnTypeForInlineClassesGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingFromReturnTypeForInlineClassesGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkBoxingOnFunctionCalls.kt") public void testCheckBoxingOnFunctionCalls() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingOnFunctionCalls.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkBoxingOnFunctionCallsGeneric.kt") public void testCheckBoxingOnFunctionCallsGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingOnFunctionCallsGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkBoxingOnLocalVariableAssignments.kt") public void testCheckBoxingOnLocalVariableAssignments() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingOnLocalVariableAssignments.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkBoxingOnLocalVariableAssignmentsGeneric.kt") public void testCheckBoxingOnLocalVariableAssignmentsGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingOnLocalVariableAssignmentsGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkBoxingUnboxingForInheritedTypeSpecializedFunctions.kt") public void testCheckBoxingUnboxingForInheritedTypeSpecializedFunctions() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingUnboxingForInheritedTypeSpecializedFunctions.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkBoxingUnboxingForInheritedTypeSpecializedFunctionsGeneric.kt") public void testCheckBoxingUnboxingForInheritedTypeSpecializedFunctionsGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingUnboxingForInheritedTypeSpecializedFunctionsGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkCallingMembersInsideInlineClass.kt") public void testCheckCallingMembersInsideInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkCallingMembersInsideInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkCallingMembersInsideInlineClassGeneric.kt") public void testCheckCallingMembersInsideInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkCallingMembersInsideInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkCastToInlineClass.kt") public void testCheckCastToInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkCastToInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkCastToInlineClassGeneric.kt") public void testCheckCastToInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkCastToInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkForInstanceOfInlineClass.kt") public void testCheckForInstanceOfInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkForInstanceOfInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkForInstanceOfInlineClassGeneric.kt") public void testCheckForInstanceOfInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkForInstanceOfInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkLambdaWithInlineClassesInFunctionalType.kt") public void testCheckLambdaWithInlineClassesInFunctionalType() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkLambdaWithInlineClassesInFunctionalType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkLambdaWithInlineClassesInFunctionalTypeGeneric.kt") public void testCheckLambdaWithInlineClassesInFunctionalTypeGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkLambdaWithInlineClassesInFunctionalTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkUnboxingResultFromTypeVariable.kt") public void testCheckUnboxingResultFromTypeVariable() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkUnboxingResultFromTypeVariable.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkUnboxingResultFromTypeVariableGeneric.kt") public void testCheckUnboxingResultFromTypeVariableGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkUnboxingResultFromTypeVariableGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("checkUnboxingResultFromTypeVariableGeneric2.kt") public void testCheckUnboxingResultFromTypeVariableGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/checkUnboxingResultFromTypeVariableGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("classInInlineClassInit.kt") public void testClassInInlineClassInit() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/classInInlineClassInit.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("classInInlineClassInitGeneric.kt") public void testClassInInlineClassInitGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/classInInlineClassInitGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("computablePropertyInsideInlineClass.kt") public void testComputablePropertyInsideInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/computablePropertyInsideInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("conformToComparableAndCallInterfaceMethod.kt") public void testConformToComparableAndCallInterfaceMethod() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/conformToComparableAndCallInterfaceMethod.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("conformToComparableAndCallInterfaceMethodGeneric.kt") public void testConformToComparableAndCallInterfaceMethodGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/conformToComparableAndCallInterfaceMethodGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("constructorCallableReference.kt") public void testConstructorCallableReference() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/constructorCallableReference.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("constructorCallableReferenceGeneric.kt") public void testConstructorCallableReferenceGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/constructorCallableReferenceGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("correctBoxingForBranchExpressions.kt") public void testCorrectBoxingForBranchExpressions() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/correctBoxingForBranchExpressions.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("correctBoxingForBranchExpressionsGeneric.kt") public void testCorrectBoxingForBranchExpressionsGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/correctBoxingForBranchExpressionsGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("createInlineClassInArgumentPosition.kt") public void testCreateInlineClassInArgumentPosition() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/createInlineClassInArgumentPosition.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("createInlineClassInArgumentPositionGeneric.kt") public void testCreateInlineClassInArgumentPositionGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/createInlineClassInArgumentPositionGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("crossinlineWithInlineClassInParameter.kt") public void testCrossinlineWithInlineClassInParameter() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/crossinlineWithInlineClassInParameter.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("crossinlineWithInlineClassInParameterGeneric.kt") public void testCrossinlineWithInlineClassInParameterGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/crossinlineWithInlineClassInParameterGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("crossinlineWithInlineClassInParameterGeneric2.kt") public void testCrossinlineWithInlineClassInParameterGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/crossinlineWithInlineClassInParameterGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("customIterator.kt") public void testCustomIterator() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/customIterator.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("defaultFunctionsFromAnyForInlineClass.kt") public void testDefaultFunctionsFromAnyForInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultFunctionsFromAnyForInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("defaultFunctionsFromAnyForInlineClassGeneric.kt") public void testDefaultFunctionsFromAnyForInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultFunctionsFromAnyForInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("defaultInterfaceMethodsInInlineClass.kt") public void testDefaultInterfaceMethodsInInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultInterfaceMethodsInInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("defaultInterfaceMethodsInInlineClassGeneric.kt") public void testDefaultInterfaceMethodsInInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultInterfaceMethodsInInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("defaultWithInlineClassArgument.kt") public void testDefaultWithInlineClassArgument() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultWithInlineClassArgument.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("defaultWithInlineClassArgumentGeneric.kt") public void testDefaultWithInlineClassArgumentGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultWithInlineClassArgumentGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("elvisWithInlineClassAndNullConstant.kt") public void testElvisWithInlineClassAndNullConstant() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/elvisWithInlineClassAndNullConstant.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("elvisWithInlineClassAndNullConstantGeneric.kt") public void testElvisWithInlineClassAndNullConstantGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/elvisWithInlineClassAndNullConstantGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("emptyConstructorForInlineClass.kt") public void testEmptyConstructorForInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/emptyConstructorForInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("emptyConstructorForInlineClassGeneric.kt") public void testEmptyConstructorForInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/emptyConstructorForInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalityChecksInlineClassNonNull.kt") public void testEqualityChecksInlineClassNonNull() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksInlineClassNonNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalityChecksInlineClassNonNullGeneric.kt") public void testEqualityChecksInlineClassNonNullGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksInlineClassNonNullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalityChecksMixedNullability.kt") public void testEqualityChecksMixedNullability() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksMixedNullability.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalityChecksMixedNullabilityGeneric.kt") public void testEqualityChecksMixedNullabilityGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksMixedNullabilityGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalityChecksNegatedInlineClassNonNull.kt") public void testEqualityChecksNegatedInlineClassNonNull() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNegatedInlineClassNonNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalityChecksNegatedInlineClassNonNullGeneric.kt") public void testEqualityChecksNegatedInlineClassNonNullGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNegatedInlineClassNonNullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalityChecksNegatedNonNull.kt") public void testEqualityChecksNegatedNonNull() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNegatedNonNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalityChecksNegatedNonNullGeneric.kt") public void testEqualityChecksNegatedNonNullGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNegatedNonNullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalityChecksNegatedNullable.kt") public void testEqualityChecksNegatedNullable() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNegatedNullable.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalityChecksNegatedNullableGeneric.kt") public void testEqualityChecksNegatedNullableGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNegatedNullableGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalityChecksNegatedNullableGeneric2.kt") public void testEqualityChecksNegatedNullableGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNegatedNullableGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalityChecksNegatedPrimitive.kt") public void testEqualityChecksNegatedPrimitive() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNegatedPrimitive.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalityChecksNegatedPrimitiveGeneric.kt") public void testEqualityChecksNegatedPrimitiveGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNegatedPrimitiveGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalityChecksNonNull.kt") public void testEqualityChecksNonNull() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNonNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalityChecksNonNullGeneric.kt") public void testEqualityChecksNonNullGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNonNullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalityChecksNullable.kt") public void testEqualityChecksNullable() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNullable.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalityChecksNullableGeneric.kt") public void testEqualityChecksNullableGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNullableGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalityChecksNullableGeneric2.kt") public void testEqualityChecksNullableGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNullableGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalityChecksPrimitive.kt") public void testEqualityChecksPrimitive() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksPrimitive.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalityChecksPrimitiveGeneric.kt") public void testEqualityChecksPrimitiveGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksPrimitiveGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalityChecksPrimitiveUnboxed.kt") public void testEqualityChecksPrimitiveUnboxed() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksPrimitiveUnboxed.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalityForBoxesOfNullableValuesOfInlineClass.kt") public void testEqualityForBoxesOfNullableValuesOfInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalityForBoxesOfNullableValuesOfInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalityForBoxesOfNullableValuesOfInlineClassGeneric.kt") public void testEqualityForBoxesOfNullableValuesOfInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalityForBoxesOfNullableValuesOfInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalsCallsLeftArgument.kt") public void testEqualsCallsLeftArgument() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalsCallsLeftArgument.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalsCallsLeftArgumentGeneric.kt") public void testEqualsCallsLeftArgumentGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalsCallsLeftArgumentGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalsEvaluationOrderInlineClass.kt") public void testEqualsEvaluationOrderInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalsEvaluationOrderInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalsEvaluationOrderInlineClassGeneric.kt") public void testEqualsEvaluationOrderInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalsEvaluationOrderInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalsEvaluationOrderNonNull.kt") public void testEqualsEvaluationOrderNonNull() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalsEvaluationOrderNonNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalsEvaluationOrderNonNullGeneric.kt") public void testEqualsEvaluationOrderNonNullGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalsEvaluationOrderNonNullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalsEvaluationOrderNullable.kt") public void testEqualsEvaluationOrderNullable() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalsEvaluationOrderNullable.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalsEvaluationOrderNullableGeneric.kt") public void testEqualsEvaluationOrderNullableGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalsEvaluationOrderNullableGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalsEvaluationOrderNullableGeneric2.kt") public void testEqualsEvaluationOrderNullableGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalsEvaluationOrderNullableGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalsEvaluationOrderPrimitive.kt") public void testEqualsEvaluationOrderPrimitive() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalsEvaluationOrderPrimitive.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalsEvaluationOrderPrimitiveGeneric.kt") public void testEqualsEvaluationOrderPrimitiveGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalsEvaluationOrderPrimitiveGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalsOperatorWithGenericCall.kt") public void testEqualsOperatorWithGenericCall() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalsOperatorWithGenericCall.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalsOperatorWithGenericCallGeneric.kt") public void testEqualsOperatorWithGenericCallGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/equalsOperatorWithGenericCallGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("extLambdaInInlineClassFun.kt") public void testExtLambdaInInlineClassFun() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/extLambdaInInlineClassFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("extLambdaInInlineClassFun2.kt") public void testExtLambdaInInlineClassFun2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/extLambdaInInlineClassFun2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("extLambdaInInlineClassFun2Generic.kt") public void testExtLambdaInInlineClassFun2Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/extLambdaInInlineClassFun2Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("extLambdaInInlineClassFunGeneric.kt") public void testExtLambdaInInlineClassFunGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/extLambdaInInlineClassFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("fieldNameClash.kt") public void testFieldNameClash() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/fieldNameClash.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("fieldNameClashGeneric.kt") public void testFieldNameClashGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/fieldNameClashGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("funInterfaceDoubleSuffux.kt") public void testFunInterfaceDoubleSuffux() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/funInterfaceDoubleSuffux.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("funInterfaceDoubleSuffux2.kt") public void testFunInterfaceDoubleSuffux2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/funInterfaceDoubleSuffux2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("functionExpression.kt") public void testFunctionExpression() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionExpression.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("functionExpressionGeneric.kt") public void testFunctionExpressionGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionExpressionGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("genericInlineClassSynthMembers.kt") public void testGenericInlineClassSynthMembers() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/genericInlineClassSynthMembers.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("genericVararg2ndConstructor.kt") public void testGenericVararg2ndConstructor() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/genericVararg2ndConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("initBlock.kt") public void testInitBlock() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/initBlock.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("initBlockGeneric.kt") public void testInitBlockGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/initBlockGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("initInCompanion.kt") public void testInitInCompanion() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/initInCompanion.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassAsLastExpressionInInLambda.kt") public void testInlineClassAsLastExpressionInInLambda() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassAsLastExpressionInInLambda.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassAsLastExpressionInInLambdaGeneric.kt") public void testInlineClassAsLastExpressionInInLambdaGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassAsLastExpressionInInLambdaGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassEqualityShouldUseTotalOrderForFloatingPointData.kt") public void testInlineClassEqualityShouldUseTotalOrderForFloatingPointData() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassEqualityShouldUseTotalOrderForFloatingPointData.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassEqualityShouldUseTotalOrderForFloatingPointDataGeneric.kt") public void testInlineClassEqualityShouldUseTotalOrderForFloatingPointDataGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassEqualityShouldUseTotalOrderForFloatingPointDataGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassFieldHandling.kt") public void testInlineClassFieldHandling() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassFieldHandling.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassFieldHandlingGeneric.kt") public void testInlineClassFieldHandlingGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassFieldHandlingGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassFunctionInvoke.kt") public void testInlineClassFunctionInvoke() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassFunctionInvoke.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassFunctionInvokeGeneric.kt") public void testInlineClassFunctionInvokeGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassFunctionInvokeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassHashCodeOverride.kt") public void testInlineClassHashCodeOverride() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassHashCodeOverride.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassInInitBlock.kt") public void testInlineClassInInitBlock() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassInInitBlock.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassInInitBlockGeneric.kt") public void testInlineClassInInitBlockGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassInInitBlockGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassInStringTemplate.kt") public void testInlineClassInStringTemplate() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassInStringTemplate.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassInStringTemplateGeneric.kt") public void testInlineClassInStringTemplateGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassInStringTemplateGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassPropertyReferenceGetAndSet.kt") public void testInlineClassPropertyReferenceGetAndSet() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassPropertyReferenceGetAndSet.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassPropertyReferenceGetAndSetGeneric.kt") public void testInlineClassPropertyReferenceGetAndSetGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassPropertyReferenceGetAndSetGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassValueCapturedInInlineLambda.kt") public void testInlineClassValueCapturedInInlineLambda() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassValueCapturedInInlineLambda.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassValueCapturedInInlineLambdaGeneric.kt") public void testInlineClassValueCapturedInInlineLambdaGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassValueCapturedInInlineLambdaGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassValueCapturedInNonInlineLambda.kt") public void testInlineClassValueCapturedInNonInlineLambda() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassValueCapturedInNonInlineLambda.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassValueCapturedInNonInlineLambdaGeneric.kt") public void testInlineClassValueCapturedInNonInlineLambdaGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassValueCapturedInNonInlineLambdaGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassValuesInsideStrings.kt") public void testInlineClassValuesInsideStrings() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassValuesInsideStrings.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassValuesInsideStringsGeneric.kt") public void testInlineClassValuesInsideStringsGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassValuesInsideStringsGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassWithCustomEquals.kt") public void testInlineClassWithCustomEquals() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassWithCustomEquals.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassWithCustomEqualsGeneric.kt") public void testInlineClassWithCustomEqualsGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassWithCustomEqualsGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassWithDefaultFunctionsFromAny.kt") public void testInlineClassWithDefaultFunctionsFromAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassWithDefaultFunctionsFromAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassWithDefaultFunctionsFromAnyGeneric.kt") public void testInlineClassWithDefaultFunctionsFromAnyGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassWithDefaultFunctionsFromAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassesAsInlineFunParameters.kt") public void testInlineClassesAsInlineFunParameters() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesAsInlineFunParameters.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassesAsInlineFunParametersGeneric.kt") public void testInlineClassesAsInlineFunParametersGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesAsInlineFunParametersGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassesCheckCast.kt") public void testInlineClassesCheckCast() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesCheckCast.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassesCheckCastGeneric.kt") public void testInlineClassesCheckCastGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesCheckCastGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassesInInlineLambdaParameters.kt") public void testInlineClassesInInlineLambdaParameters() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesInInlineLambdaParameters.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassesInInlineLambdaParametersGeneric.kt") public void testInlineClassesInInlineLambdaParametersGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesInInlineLambdaParametersGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassesRefTypesInInlineLambdaParameters.kt") public void testInlineClassesRefTypesInInlineLambdaParameters() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesRefTypesInInlineLambdaParameters.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassesRefTypesInInlineLambdaParametersGeneric.kt") public void testInlineClassesRefTypesInInlineLambdaParametersGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesRefTypesInInlineLambdaParametersGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineExtLambdaInInlineClassFun.kt") public void testInlineExtLambdaInInlineClassFun() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineExtLambdaInInlineClassFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineExtLambdaInInlineClassFun2.kt") public void testInlineExtLambdaInInlineClassFun2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineExtLambdaInInlineClassFun2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineExtLambdaInInlineClassFun2Generic.kt") public void testInlineExtLambdaInInlineClassFun2Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineExtLambdaInInlineClassFun2Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineExtLambdaInInlineClassFunGeneric.kt") public void testInlineExtLambdaInInlineClassFunGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineExtLambdaInInlineClassFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineFunctionInsideInlineClass.kt") public void testInlineFunctionInsideInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineFunctionInsideInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineFunctionInsideInlineClassGeneric.kt") public void testInlineFunctionInsideInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineFunctionInsideInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("iterateOverArrayOfInlineClassValues.kt") public void testIterateOverArrayOfInlineClassValues() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/iterateOverArrayOfInlineClassValues.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("iterateOverArrayOfInlineClassValuesGeneric.kt") public void testIterateOverArrayOfInlineClassValuesGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/iterateOverArrayOfInlineClassValuesGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("iterateOverListOfInlineClassValues.kt") public void testIterateOverListOfInlineClassValues() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/iterateOverListOfInlineClassValues.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("iterateOverListOfInlineClassValuesGeneric.kt") public void testIterateOverListOfInlineClassValuesGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/iterateOverListOfInlineClassValuesGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("jvmInline.kt") public void testJvmInline() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/jvmInline.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt25246.kt") public void testKt25246() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt25246.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt25750.kt") public void testKt25750() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt25750.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt25750Generic.kt") public void testKt25750Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt25750Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt25771.kt") public void testKt25771() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt25771.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt26103.kt") public void testKt26103() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt26103.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt26103_contravariantUnderlyingType.kt") public void testKt26103_contravariantUnderlyingType() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt26103_contravariantUnderlyingType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt26103_covariantUnderlyingType.kt") public void testKt26103_covariantUnderlyingType() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt26103_covariantUnderlyingType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt26103_original.kt") public void testKt26103_original() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt26103_original.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27096.kt") public void testKt27096() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27096.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27096Generic.kt") public void testKt27096Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27096Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27096_enum.kt") public void testKt27096_enum() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27096_enum.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27096_enumGeneric.kt") public void testKt27096_enumGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27096_enumGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27096_functional.kt") public void testKt27096_functional() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27096_functional.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27096_functionalGeneric.kt") public void testKt27096_functionalGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27096_functionalGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27096_innerClass.kt") public void testKt27096_innerClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27096_innerClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27096_nullablePrimitive.kt") public void testKt27096_nullablePrimitive() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27096_nullablePrimitive.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27096_nullablePrimitiveGeneric.kt") public void testKt27096_nullablePrimitiveGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27096_nullablePrimitiveGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27096_nullablePrimitiveGeneric2.kt") public void testKt27096_nullablePrimitiveGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27096_nullablePrimitiveGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27096_nullableReference.kt") public void testKt27096_nullableReference() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27096_nullableReference.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27096_nullableReferenceGeneric.kt") public void testKt27096_nullableReferenceGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27096_nullableReferenceGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27096_nullableReferenceGeneric2.kt") public void testKt27096_nullableReferenceGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27096_nullableReferenceGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27096_primitive.kt") public void testKt27096_primitive() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27096_primitive.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27096_primitiveGeneric.kt") public void testKt27096_primitiveGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27096_primitiveGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27096_reference.kt") public void testKt27096_reference() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27096_reference.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27096_referenceGeneric.kt") public void testKt27096_referenceGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27096_referenceGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27113.kt") public void testKt27113() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27113.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27113a.kt") public void testKt27113a() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27113a.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27113aGeneric.kt") public void testKt27113aGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27113aGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27132.kt") public void testKt27132() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27132.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27132Generic.kt") public void testKt27132Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27132Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27140.kt") public void testKt27140() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27140.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27140Generic.kt") public void testKt27140Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27140Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27705.kt") public void testKt27705() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27705.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27705Generic.kt") public void testKt27705Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27705Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27706.kt") public void testKt27706() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27706.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27706Generic.kt") public void testKt27706Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt27706Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt28405.kt") public void testKt28405() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt28405.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt28585.kt") public void testKt28585() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt28585.kt"); } + @Test @TestMetadata("kt31994.kt") public void testKt31994() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt31994.kt"); } + @Test @TestMetadata("kt32793.kt") public void testKt32793() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt32793.kt"); } + @Test @TestMetadata("kt33119.kt") public void testKt33119() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt33119.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt33119Generic.kt") public void testKt33119Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt33119Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt34268.kt") public void testKt34268() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt34268.kt"); } + @Test @TestMetadata("kt34902.kt") public void testKt34902() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt34902.kt"); } + @Test @TestMetadata("kt37998.kt") public void testKt37998() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt37998.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt37998Generic.kt") public void testKt37998Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt37998Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt38680.kt") public void testKt38680() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt38680.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt38680Generic.kt") public void testKt38680Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt38680Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt38680a.kt") public void testKt38680a() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt38680a.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt38680aGeneric.kt") public void testKt38680aGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt38680aGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt38680b.kt") public void testKt38680b() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt38680b.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt38680bGeneric.kt") public void testKt38680bGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt38680bGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt44141.kt") public void testKt44141() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt44141.kt"); } + @Test @TestMetadata("kt44867.kt") public void testKt44867() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt44867.kt"); } + @Test @TestMetadata("kt44978.kt") public void testKt44978() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt44978.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt45084.kt") public void testKt45084() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt45084.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt45084Generic.kt") public void testKt45084Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt45084Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt45991.kt") public void testKt45991() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt45991.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt46554.kt") public void testKt46554() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt46554.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt46554Generic.kt") public void testKt46554Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt46554Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt47762.kt") public void testKt47762() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt47762.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt47762Generic.kt") public void testKt47762Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt47762Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt47823.kt") public void testKt47823() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt47823.kt"); } + @Test @TestMetadata("kt50974_resultMultiModule.kt") public void testKt50974_resultMultiModule() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt50974_resultMultiModule.kt"); } + @Test @TestMetadata("kt51157.kt") public void testKt51157() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt51157.kt"); } + @Test @TestMetadata("kt51254.kt") public void testKt51254() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt51254.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt52913.kt") public void testKt52913() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt52913.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt54455.kt") public void testKt54455() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt54455.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt57973.kt") public void testKt57973() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/kt57973.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("lateinitInlineClasses.kt") public void testLateinitInlineClasses() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/lateinitInlineClasses.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("mangledDefaultParameterFunction.kt") public void testMangledDefaultParameterFunction() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/mangledDefaultParameterFunction.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("mangledDefaultParameterFunctionGeneric.kt") public void testMangledDefaultParameterFunctionGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/mangledDefaultParameterFunctionGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("mangledSuperCalls.kt") public void testMangledSuperCalls() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/mangledSuperCalls.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("mangledSuperCallsGeneric.kt") public void testMangledSuperCallsGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/mangledSuperCallsGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("multifileClass.kt") public void testMultifileClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/multifileClass.kt"); } + @Test @TestMetadata("nestedInlineClass.kt") public void testNestedInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/nestedInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("nestedInlineClassGeneric.kt") public void testNestedInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/nestedInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("noAssertionsOnInlineClassBasedOnNullableType.kt") public void testNoAssertionsOnInlineClassBasedOnNullableType() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/noAssertionsOnInlineClassBasedOnNullableType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("noAssertionsOnInlineClassBasedOnNullableTypeGeneric.kt") public void testNoAssertionsOnInlineClassBasedOnNullableTypeGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/noAssertionsOnInlineClassBasedOnNullableTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("noReturnTypeMangling.kt") public void testNoReturnTypeMangling() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/noReturnTypeMangling.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("noReturnTypeManglingGeneric.kt") public void testNoReturnTypeManglingGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/noReturnTypeManglingGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("nullableEqeqNonNull.kt") public void testNullableEqeqNonNull() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/nullableEqeqNonNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("nullableEqeqNonNullGeneric.kt") public void testNullableEqeqNonNullGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/nullableEqeqNonNullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("nullableWrapperEquality.kt") public void testNullableWrapperEquality() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/nullableWrapperEquality.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("nullableWrapperEqualityGeneric.kt") public void testNullableWrapperEqualityGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/nullableWrapperEqualityGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("nullableWrapperEqualityGeneric2.kt") public void testNullableWrapperEqualityGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/nullableWrapperEqualityGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overrideReturnNothing.kt") public void testOverrideReturnNothing() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/overrideReturnNothing.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overridingFunCallingPrivateFun.kt") public void testOverridingFunCallingPrivateFun() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/overridingFunCallingPrivateFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overridingFunCallingPrivateFunGeneric.kt") public void testOverridingFunCallingPrivateFunGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/overridingFunCallingPrivateFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("passInlineClassAsVararg.kt") public void testPassInlineClassAsVararg() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/passInlineClassAsVararg.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("passInlineClassAsVarargGeneric.kt") public void testPassInlineClassAsVarargGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/passInlineClassAsVarargGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("passInlineClassWithSpreadOperatorToVarargs.kt") public void testPassInlineClassWithSpreadOperatorToVarargs() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/passInlineClassWithSpreadOperatorToVarargs.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("passInlineClassWithSpreadOperatorToVarargsGeneric.kt") public void testPassInlineClassWithSpreadOperatorToVarargsGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/passInlineClassWithSpreadOperatorToVarargsGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("privateConstructorFunInterfaceMultiModule.kt") public void testPrivateConstructorFunInterfaceMultiModule() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/privateConstructorFunInterfaceMultiModule.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("privateConstructorFunInterfaceMultiModuleGeneric.kt") public void testPrivateConstructorFunInterfaceMultiModuleGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/privateConstructorFunInterfaceMultiModuleGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("propertyLoweringOrder.kt") public void testPropertyLoweringOrder() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/propertyLoweringOrder.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("propertyLoweringOrderGeneric.kt") public void testPropertyLoweringOrderGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/propertyLoweringOrderGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("referToPropertyInCompanionObjectOfInlineClass.kt") public void testReferToPropertyInCompanionObjectOfInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/referToPropertyInCompanionObjectOfInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("referToPropertyInCompanionObjectOfInlineClassGeneric.kt") public void testReferToPropertyInCompanionObjectOfInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/referToPropertyInCompanionObjectOfInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("referToUnderlyingPropertyInsideInlineClass.kt") public void testReferToUnderlyingPropertyInsideInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/referToUnderlyingPropertyInsideInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("referToUnderlyingPropertyInsideInlineClassGeneric.kt") public void testReferToUnderlyingPropertyInsideInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/referToUnderlyingPropertyInsideInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("referToUnderlyingPropertyOfInlineClass.kt") public void testReferToUnderlyingPropertyOfInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/referToUnderlyingPropertyOfInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("referToUnderlyingPropertyOfInlineClassGeneric.kt") public void testReferToUnderlyingPropertyOfInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/referToUnderlyingPropertyOfInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("removeInInlineCollectionOfInlineClassAsInt.kt") public void testRemoveInInlineCollectionOfInlineClassAsInt() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/removeInInlineCollectionOfInlineClassAsInt.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("result.kt") public void testResult() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/result.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("resultGeneric.kt") public void testResultGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/resultGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("resultGeneric2.kt") public void testResultGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/resultGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("resultInlining.kt") public void testResultInlining() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/resultInlining.kt"); } + @Test @TestMetadata("resultRunCatchingOrElse.kt") public void testResultRunCatchingOrElse() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/resultRunCatchingOrElse.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("safeAsOfTypeParameterWithInlineClassBound.kt") public void testSafeAsOfTypeParameterWithInlineClassBound() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/safeAsOfTypeParameterWithInlineClassBound.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("safeAsOfTypeParameterWithInlineClassBoundGeneric.kt") public void testSafeAsOfTypeParameterWithInlineClassBoundGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/safeAsOfTypeParameterWithInlineClassBoundGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("samWrapperDifferentModule.kt") public void testSamWrapperDifferentModule() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/samWrapperDifferentModule.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("samWrapperDifferentModuleGeneric.kt") public void testSamWrapperDifferentModuleGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/samWrapperDifferentModuleGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("secondaryConstructorVisibilies.kt") public void testSecondaryConstructorVisibilies() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/secondaryConstructorVisibilies.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("secondaryConstructorWithVararg.kt") public void testSecondaryConstructorWithVararg() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/secondaryConstructorWithVararg.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("secondaryConstructorWithVarargGeneric.kt") public void testSecondaryConstructorWithVarargGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/secondaryConstructorWithVarargGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("secondaryConstructorsInsideInlineClass.kt") public void testSecondaryConstructorsInsideInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/secondaryConstructorsInsideInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("secondaryConstructorsInsideInlineClassGeneric.kt") public void testSecondaryConstructorsInsideInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/secondaryConstructorsInsideInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("secondaryConstructorsInsideInlineClassWithPrimitiveCarrierType.kt") public void testSecondaryConstructorsInsideInlineClassWithPrimitiveCarrierType() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/secondaryConstructorsInsideInlineClassWithPrimitiveCarrierType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("secondaryConstructorsInsideInlineClassWithPrimitiveCarrierTypeGeneric.kt") public void testSecondaryConstructorsInsideInlineClassWithPrimitiveCarrierTypeGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/secondaryConstructorsInsideInlineClassWithPrimitiveCarrierTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("secondaryConstructorsWithBody.kt") public void testSecondaryConstructorsWithBody() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/secondaryConstructorsWithBody.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("simpleSecondaryConstructor.kt") public void testSimpleSecondaryConstructor() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/simpleSecondaryConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("simpleSecondaryConstructorGeneric.kt") public void testSimpleSecondaryConstructorGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/simpleSecondaryConstructorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("smartCastOnThisOfInlineClassType.kt") public void testSmartCastOnThisOfInlineClassType() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/smartCastOnThisOfInlineClassType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("smartCastOnThisOfInlineClassTypeGeneric.kt") public void testSmartCastOnThisOfInlineClassTypeGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/smartCastOnThisOfInlineClassTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("stringPlus.kt") public void testStringPlus() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/stringPlus.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("stringPlusGeneric.kt") public void testStringPlusGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/stringPlusGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("toStringCallingPrivateFun.kt") public void testToStringCallingPrivateFun() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/toStringCallingPrivateFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("toStringCallingPrivateFunGeneric.kt") public void testToStringCallingPrivateFunGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/toStringCallingPrivateFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("toStringOfUnboxedNullable.kt") public void testToStringOfUnboxedNullable() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/toStringOfUnboxedNullable.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("toStringOfUnboxedNullableGeneric.kt") public void testToStringOfUnboxedNullableGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/toStringOfUnboxedNullableGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("typeChecksForInlineClasses.kt") public void testTypeChecksForInlineClasses() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/typeChecksForInlineClasses.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("typeChecksForInlineClassesGeneric.kt") public void testTypeChecksForInlineClassesGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/typeChecksForInlineClassesGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("UIntArraySortExample.kt") public void testUIntArraySortExample() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/UIntArraySortExample.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("UIntArraySortExampleGeneric.kt") public void testUIntArraySortExampleGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/UIntArraySortExampleGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("UIntSafeAsInt.kt") public void testUIntSafeAsInt() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/UIntSafeAsInt.kt"); } + @Test @TestMetadata("unboxNullableValueOfInlineClassWithNonNullUnderlyingType.kt") public void testUnboxNullableValueOfInlineClassWithNonNullUnderlyingType() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxNullableValueOfInlineClassWithNonNullUnderlyingType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("unboxNullableValueOfInlineClassWithNonNullUnderlyingTypeGeneric.kt") public void testUnboxNullableValueOfInlineClassWithNonNullUnderlyingTypeGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxNullableValueOfInlineClassWithNonNullUnderlyingTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("unboxNullableValueOfInlineClassWithNullableInlineClassUnderlyingTypeGWI.kt") public void testUnboxNullableValueOfInlineClassWithNullableInlineClassUnderlyingTypeGWI() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxNullableValueOfInlineClassWithNullableInlineClassUnderlyingTypeGWI.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("unboxNullableValueOfInlineClassWithNullableInlineClassUnderlyingTypeGWI2.kt") public void testUnboxNullableValueOfInlineClassWithNullableInlineClassUnderlyingTypeGWI2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxNullableValueOfInlineClassWithNullableInlineClassUnderlyingTypeGWI2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("unboxNullableValueOfInlineClassWithNullablePrimitiveUnderlyingType.kt") public void testUnboxNullableValueOfInlineClassWithNullablePrimitiveUnderlyingType() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxNullableValueOfInlineClassWithNullablePrimitiveUnderlyingType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("unboxNullableValueOfInlineClassWithNullablePrimitiveUnderlyingTypeGWI.kt") public void testUnboxNullableValueOfInlineClassWithNullablePrimitiveUnderlyingTypeGWI() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxNullableValueOfInlineClassWithNullablePrimitiveUnderlyingTypeGWI.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("unboxNullableValueOfInlineClassWithNullablePrimitiveUnderlyingTypeGWI2.kt") public void testUnboxNullableValueOfInlineClassWithNullablePrimitiveUnderlyingTypeGWI2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxNullableValueOfInlineClassWithNullablePrimitiveUnderlyingTypeGWI2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("unboxNullableValueOfInlineClassWithNullablePrimitiveUnderlyingTypeGeneric.kt") public void testUnboxNullableValueOfInlineClassWithNullablePrimitiveUnderlyingTypeGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxNullableValueOfInlineClassWithNullablePrimitiveUnderlyingTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("unboxNullableValueOfInlineClassWithPrimitiveUnderlyingType.kt") public void testUnboxNullableValueOfInlineClassWithPrimitiveUnderlyingType() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxNullableValueOfInlineClassWithPrimitiveUnderlyingType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("unboxNullableValueOfInlineClassWithPrimitiveUnderlyingTypeGeneric.kt") public void testUnboxNullableValueOfInlineClassWithPrimitiveUnderlyingTypeGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxNullableValueOfInlineClassWithPrimitiveUnderlyingTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("unboxParameterOfSuspendLambdaBeforeInvoke.kt") public void testUnboxParameterOfSuspendLambdaBeforeInvoke() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxParameterOfSuspendLambdaBeforeInvoke.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("unboxParameterOfSuspendLambdaBeforeInvokeGeneric.kt") public void testUnboxParameterOfSuspendLambdaBeforeInvokeGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxParameterOfSuspendLambdaBeforeInvokeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("unboxReceiverOnCallingMethodFromInlineClass.kt") public void testUnboxReceiverOnCallingMethodFromInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxReceiverOnCallingMethodFromInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("unboxReceiverOnCallingMethodFromInlineClassGeneric.kt") public void testUnboxReceiverOnCallingMethodFromInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxReceiverOnCallingMethodFromInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("unboxResultParameterWhenCapturingToCrossinlineLambda.kt") public void testUnboxResultParameterWhenCapturingToCrossinlineLambda() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxResultParameterWhenCapturingToCrossinlineLambda.kt"); } + @Test @TestMetadata("unboxValueFromPlatformType.kt") public void testUnboxValueFromPlatformType() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxValueFromPlatformType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("unboxValueFromPlatformTypeGeneric.kt") public void testUnboxValueFromPlatformTypeGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxValueFromPlatformTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("unboxValueOfAnyBeforeMethodInvocation.kt") public void testUnboxValueOfAnyBeforeMethodInvocation() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxValueOfAnyBeforeMethodInvocation.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("unboxValueOfAnyBeforeMethodInvocationGeneric.kt") public void testUnboxValueOfAnyBeforeMethodInvocationGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxValueOfAnyBeforeMethodInvocationGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("unboxValueOfAnyBeforeMethodInvocationGeneric2.kt") public void testUnboxValueOfAnyBeforeMethodInvocationGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxValueOfAnyBeforeMethodInvocationGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("unboxValueOfNullableInlineClassUsingInlineFunction.kt") public void testUnboxValueOfNullableInlineClassUsingInlineFunction() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxValueOfNullableInlineClassUsingInlineFunction.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("useInlineClassesInsideElvisOperator.kt") public void testUseInlineClassesInsideElvisOperator() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/useInlineClassesInsideElvisOperator.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("useInlineClassesInsideElvisOperatorGeneric.kt") public void testUseInlineClassesInsideElvisOperatorGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/useInlineClassesInsideElvisOperatorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("useInlineFunctionInsideInlineClass.kt") public void testUseInlineFunctionInsideInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/useInlineFunctionInsideInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("useInlineFunctionInsideInlineClassGeneric.kt") public void testUseInlineFunctionInsideInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/useInlineFunctionInsideInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("useThisInsideInlineClass.kt") public void testUseThisInsideInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/useThisInsideInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("useThisInsideInlineClassGeneric.kt") public void testUseThisInsideInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/useThisInsideInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("whenWithSubject.kt") public void testWhenWithSubject() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/whenWithSubject.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("whenWithSubjectGeneric.kt") public void testWhenWithSubjectGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/whenWithSubjectGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class BoxReturnValueInLambda extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - - private void runTest(String testDataFilePath, java.util.function.Function transformer) throws Exception { - KotlinTestUtils.runTest0(path -> doTestWithTransformer(path, transformer), TargetBackend.WASM, testDataFilePath); - } - + public class BoxReturnValueInLambda { + @Test public void testAllFilesPresentInBoxReturnValueInLambda() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("boxAny.kt") public void testBoxAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxAnyGeneric.kt") public void testBoxAnyGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxFunLiteralAny.kt") public void testBoxFunLiteralAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxFunLiteralAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxFunLiteralAnyGeneric.kt") public void testBoxFunLiteralAnyGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxFunLiteralAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxInt.kt") public void testBoxInt() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxInt.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxIntGeneric.kt") public void testBoxIntGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxIntGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableAny.kt") public void testBoxNullableAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableAnyGeneric.kt") public void testBoxNullableAnyGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableAnyGeneric2.kt") public void testBoxNullableAnyGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableAnyGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableAnyNull.kt") public void testBoxNullableAnyNull() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableAnyNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableAnyNullGeneric.kt") public void testBoxNullableAnyNullGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableAnyNullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableAnyNullGeneric2.kt") public void testBoxNullableAnyNullGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableAnyNullGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableInt.kt") public void testBoxNullableInt() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableInt.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableIntGeneric.kt") public void testBoxNullableIntGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableIntGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableIntGeneric2.kt") public void testBoxNullableIntGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableIntGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableIntNull.kt") public void testBoxNullableIntNull() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableIntNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableIntNullGeneric.kt") public void testBoxNullableIntNullGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableIntNullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableIntNullGeneric2.kt") public void testBoxNullableIntNullGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableIntNullGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableString.kt") public void testBoxNullableString() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableString.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableStringGeneric.kt") public void testBoxNullableStringGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableStringGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableStringGeneric2.kt") public void testBoxNullableStringGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableStringGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableStringNull.kt") public void testBoxNullableStringNull() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableStringNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableStringNullGeneric.kt") public void testBoxNullableStringNullGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableStringNullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxNullableStringNullGeneric2.kt") public void testBoxNullableStringNullGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableStringNullGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxString.kt") public void testBoxString() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxString.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxStringGeneric.kt") public void testBoxStringGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxStringGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27586_1.kt") public void testKt27586_1() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/kt27586_1.kt"); } + @Test @TestMetadata("kt27586_2.kt") public void testKt27586_2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/kt27586_2.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class BoxReturnValueOnOverride extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - - private void runTest(String testDataFilePath, java.util.function.Function transformer) throws Exception { - KotlinTestUtils.runTest0(path -> doTestWithTransformer(path, transformer), TargetBackend.WASM, testDataFilePath); - } - + public class BoxReturnValueOnOverride { + @Test public void testAllFilesPresentInBoxReturnValueOnOverride() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("boxReturnValueInDefaultMethod.kt") public void testBoxReturnValueInDefaultMethod() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/boxReturnValueInDefaultMethod.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boxReturnValueInDefaultMethodGenericInt.kt") public void testBoxReturnValueInDefaultMethodGenericInt() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/boxReturnValueInDefaultMethodGenericInt.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("covariantOverrideChainErasedToAny.kt") public void testCovariantOverrideChainErasedToAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("covariantOverrideChainErasedToAnyGeneric.kt") public void testCovariantOverrideChainErasedToAnyGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("covariantOverrideChainErasedToNullableAny.kt") public void testCovariantOverrideChainErasedToNullableAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToNullableAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("covariantOverrideChainErasedToNullableAnyGeneric.kt") public void testCovariantOverrideChainErasedToNullableAnyGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToNullableAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("covariantOverrideChainErasedToNullableAnyGeneric2.kt") public void testCovariantOverrideChainErasedToNullableAnyGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToNullableAnyGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("covariantOverrideErasedToAny.kt") public void testCovariantOverrideErasedToAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("covariantOverrideErasedToAnyGeneric.kt") public void testCovariantOverrideErasedToAnyGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("covariantOverrideErasedToInterface.kt") public void testCovariantOverrideErasedToInterface() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToInterface.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("covariantOverrideErasedToInterfaceGeneric.kt") public void testCovariantOverrideErasedToInterfaceGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToInterfaceGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("covariantOverrideErasedToPrimitive.kt") public void testCovariantOverrideErasedToPrimitive() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToPrimitive.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("covariantOverrideErasedToPrimitiveGeneric.kt") public void testCovariantOverrideErasedToPrimitiveGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToPrimitiveGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("covariantOverrideListVsMutableList.kt") public void testCovariantOverrideListVsMutableList() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideListVsMutableList.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("covariantOverrideListVsMutableListGeneric.kt") public void testCovariantOverrideListVsMutableListGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideListVsMutableListGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("covariantOverrideUnrelatedInterfaces.kt") public void testCovariantOverrideUnrelatedInterfaces() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideUnrelatedInterfaces.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("covariantOverrideUnrelatedInterfacesGeneric.kt") public void testCovariantOverrideUnrelatedInterfacesGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideUnrelatedInterfacesGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("genericOverride.kt") public void testGenericOverride() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverride.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("genericOverrideGeneric.kt") public void testGenericOverrideGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverrideGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("genericOverrideSpecialized.kt") public void testGenericOverrideSpecialized() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverrideSpecialized.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("genericOverrideSpecializedGeneric.kt") public void testGenericOverrideSpecializedGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverrideSpecializedGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassInOverriddenReturnTypes.kt") public void testInlineClassInOverriddenReturnTypes() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/inlineClassInOverriddenReturnTypes.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassInOverriddenReturnTypesGeneric.kt") public void testInlineClassInOverriddenReturnTypesGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/inlineClassInOverriddenReturnTypesGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt28483.kt") public void testKt28483() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt28483.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt28483Generic.kt") public void testKt28483Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt28483Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt28483Generic2.kt") public void testKt28483Generic2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt28483Generic2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt31585.kt") public void testKt31585() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt31585.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt31585Generic.kt") public void testKt31585Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt31585Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt35234.kt") public void testKt35234() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt35234.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt35234Generic.kt") public void testKt35234Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt35234Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt35234a.kt") public void testKt35234a() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt35234a.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overrideGenericWithInlineClass.kt") public void testOverrideGenericWithInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overrideGenericWithInlineClassGeneric.kt") public void testOverrideGenericWithInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullAny.kt") public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullAnyGeneric.kt") public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullAnyGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAny.kt") public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyG.kt") public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyG() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyG.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyG2.kt") public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyG2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyG2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNG.kt") public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNG() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNG.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNG2.kt") public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNG2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNG2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNull.kt") public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNull() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overrideNullableInlineClassWithNonNullAny.kt") public void testOverrideNullableInlineClassWithNonNullAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overrideNullableInlineClassWithNonNullAnyGeneric.kt") public void testOverrideNullableInlineClassWithNonNullAnyGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overrideNullableInlineClassWithNonNullNullableAny.kt") public void testOverrideNullableInlineClassWithNonNullNullableAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overrideNullableInlineClassWithNonNullNullableAnyGeneric.kt") public void testOverrideNullableInlineClassWithNonNullNullableAnyGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overrideNullableInlineClassWithNonNullNullableAnyGeneric2.kt") public void testOverrideNullableInlineClassWithNonNullNullableAnyGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAnyGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overrideNullableInlineClassWithNonNullNullableAnyNull.kt") public void testOverrideNullableInlineClassWithNonNullNullableAnyNull() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAnyNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overrideNullableInlineClassWithNonNullNullableAnyNullGeneric.kt") public void testOverrideNullableInlineClassWithNonNullNullableAnyNullGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAnyNullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overrideNullableInlineClassWithNonNullNullableAnyNullGeneric2.kt") public void testOverrideNullableInlineClassWithNonNullNullableAnyNullGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAnyNullGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("relatedReturnTypes1a.kt") public void testRelatedReturnTypes1a() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1a.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("relatedReturnTypes1aGeneric.kt") public void testRelatedReturnTypes1aGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1aGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("relatedReturnTypes1b.kt") public void testRelatedReturnTypes1b() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1b.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("relatedReturnTypes1bGeneric.kt") public void testRelatedReturnTypes1bGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1bGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("relatedReturnTypes2a.kt") public void testRelatedReturnTypes2a() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2a.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("relatedReturnTypes2aGeneric.kt") public void testRelatedReturnTypes2aGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2aGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("relatedReturnTypes2b.kt") public void testRelatedReturnTypes2b() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2b.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("relatedReturnTypes2bGeneric.kt") public void testRelatedReturnTypes2bGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2bGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("uncastInlineClassToAnyAndBack.kt") public void testUncastInlineClassToAnyAndBack() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/uncastInlineClassToAnyAndBack.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("uncastInlineClassToAnyAndBackGeneric.kt") public void testUncastInlineClassToAnyAndBackGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/uncastInlineClassToAnyAndBackGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("unrelatedGenerics.kt") public void testUnrelatedGenerics() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/unrelatedGenerics.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("unrelatedGenericsGeneric.kt") public void testUnrelatedGenericsGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/unrelatedGenericsGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/callableReferences") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class CallableReferences extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - - private void runTest(String testDataFilePath, java.util.function.Function transformer) throws Exception { - KotlinTestUtils.runTest0(path -> doTestWithTransformer(path, transformer), TargetBackend.WASM, testDataFilePath); - } - + public class CallableReferences { + @Test public void testAllFilesPresentInCallableReferences() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/callableReferences"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("boundInlineClassExtensionFun.kt") public void testBoundInlineClassExtensionFun() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassExtensionFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boundInlineClassExtensionFunGeneric.kt") public void testBoundInlineClassExtensionFunGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassExtensionFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boundInlineClassExtensionVal.kt") public void testBoundInlineClassExtensionVal() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassExtensionVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boundInlineClassExtensionValGeneric.kt") public void testBoundInlineClassExtensionValGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassExtensionValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boundInlineClassMemberFun.kt") public void testBoundInlineClassMemberFun() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassMemberFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boundInlineClassMemberFunGeneric.kt") public void testBoundInlineClassMemberFunGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassMemberFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boundInlineClassMemberVal.kt") public void testBoundInlineClassMemberVal() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassMemberVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boundInlineClassMemberValGeneric.kt") public void testBoundInlineClassMemberValGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassMemberValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boundInlineClassPrimaryVal.kt") public void testBoundInlineClassPrimaryVal() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassPrimaryVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("boundInlineClassPrimaryValGeneric.kt") public void testBoundInlineClassPrimaryValGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassPrimaryValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("constructorWithInlineClassParameters.kt") public void testConstructorWithInlineClassParameters() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/constructorWithInlineClassParameters.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("constructorWithInlineClassParametersGeneric.kt") public void testConstructorWithInlineClassParametersGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/constructorWithInlineClassParametersGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalsHashCodeToString.kt") public void testEqualsHashCodeToString() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/equalsHashCodeToString.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("equalsHashCodeToStringGeneric.kt") public void testEqualsHashCodeToStringGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/equalsHashCodeToStringGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("funWithInlineClassParameters.kt") public void testFunWithInlineClassParameters() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/funWithInlineClassParameters.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("funWithInlineClassParametersGeneric.kt") public void testFunWithInlineClassParametersGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/funWithInlineClassParametersGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassExtensionFun.kt") public void testInlineClassExtensionFun() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassExtensionFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassExtensionFunGeneric.kt") public void testInlineClassExtensionFunGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassExtensionFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassExtensionVal.kt") public void testInlineClassExtensionVal() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassExtensionVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassExtensionValGeneric.kt") public void testInlineClassExtensionValGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassExtensionValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassInternalPrimaryVal.kt") public void testInlineClassInternalPrimaryVal() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassInternalPrimaryVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassInternalPrimaryValGeneric.kt") public void testInlineClassInternalPrimaryValGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassInternalPrimaryValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassMemberFun.kt") public void testInlineClassMemberFun() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassMemberFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassMemberFunGeneric.kt") public void testInlineClassMemberFunGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassMemberFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassMemberVal.kt") public void testInlineClassMemberVal() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassMemberVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassMemberValGeneric.kt") public void testInlineClassMemberValGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassMemberValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassPrimaryConstructor.kt") public void testInlineClassPrimaryConstructor() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrimaryConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassPrimaryConstructorGeneric.kt") public void testInlineClassPrimaryConstructorGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrimaryConstructorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassPrimaryVal.kt") public void testInlineClassPrimaryVal() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrimaryVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassPrimaryValGeneric.kt") public void testInlineClassPrimaryValGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrimaryValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassPrivatePrimaryVal.kt") public void testInlineClassPrivatePrimaryVal() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrivatePrimaryVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassPrivatePrimaryValGeneric.kt") public void testInlineClassPrivatePrimaryValGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrivatePrimaryValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassTypeBoundMemberVar.kt") public void testInlineClassTypeBoundMemberVar() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeBoundMemberVar.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassTypeBoundMemberVarGeneric.kt") public void testInlineClassTypeBoundMemberVarGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeBoundMemberVarGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassTypeMemberVar.kt") public void testInlineClassTypeMemberVar() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeMemberVar.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassTypeMemberVarGeneric.kt") public void testInlineClassTypeMemberVarGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeMemberVarGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassTypeTopLevelVar.kt") public void testInlineClassTypeTopLevelVar() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeTopLevelVar.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassTypeTopLevelVarGeneric.kt") public void testInlineClassTypeTopLevelVarGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeTopLevelVarGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt37986.kt") public void testKt37986() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/kt37986.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt37986Generic.kt") public void testKt37986Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/kt37986Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/callableReferences/let") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Let extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - - private void runTest(String testDataFilePath, java.util.function.Function transformer) throws Exception { - KotlinTestUtils.runTest0(path -> doTestWithTransformer(path, transformer), TargetBackend.WASM, testDataFilePath); - } - + public class Let { + @Test public void testAllFilesPresentInLet() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/callableReferences/let"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("any.kt") public void testAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/any.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("anyGeneric.kt") public void testAnyGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/anyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("anyN.kt") public void testAnyN() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/anyN.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("anyNGeneric.kt") public void testAnyNGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/anyNGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("anyNGeneric2.kt") public void testAnyNGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/anyNGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("int.kt") public void testInt() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/int.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("intGeneric.kt") public void testIntGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/intGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("intN.kt") public void testIntN() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/intN.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("intNGeneric.kt") public void testIntNGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/intNGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("intNGeneric2.kt") public void testIntNGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/intNGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("null.kt") public void testNull() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/null.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("nullGeneric.kt") public void testNullGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/nullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("result.kt") public void testResult() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/result.kt"); } + @Test @TestMetadata("string.kt") public void testString() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/string.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("stringGeneric.kt") public void testStringGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/stringGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("stringN.kt") public void testStringN() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/stringN.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("stringNGeneric.kt") public void testStringNGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/stringNGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("stringNGeneric2.kt") public void testStringNGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/stringNGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); @@ -16365,1710 +18595,1877 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ContextsAndAccessors extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - - private void runTest(String testDataFilePath, java.util.function.Function transformer) throws Exception { - KotlinTestUtils.runTest0(path -> doTestWithTransformer(path, transformer), TargetBackend.WASM, testDataFilePath); - } - + public class ContextsAndAccessors { + @Test @TestMetadata("accessPrivateInlineClassCompanionMethod.kt") public void testAccessPrivateInlineClassCompanionMethod() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassCompanionMethod.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("accessPrivateInlineClassCompanionMethod2.kt") public void testAccessPrivateInlineClassCompanionMethod2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassCompanionMethod2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("accessPrivateInlineClassCompanionMethod2Generic.kt") public void testAccessPrivateInlineClassCompanionMethod2Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassCompanionMethod2Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("accessPrivateInlineClassCompanionMethodGeneric.kt") public void testAccessPrivateInlineClassCompanionMethodGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassCompanionMethodGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("accessPrivateInlineClassConstructorFromCompanion.kt") public void testAccessPrivateInlineClassConstructorFromCompanion() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassConstructorFromCompanion.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("accessPrivateInlineClassConstructorFromCompanionGeneric.kt") public void testAccessPrivateInlineClassConstructorFromCompanionGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassConstructorFromCompanionGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("accessPrivateInlineClassConstructorFromLambda.kt") public void testAccessPrivateInlineClassConstructorFromLambda() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassConstructorFromLambda.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("accessPrivateInlineClassConstructorFromLambdaGeneric.kt") public void testAccessPrivateInlineClassConstructorFromLambdaGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassConstructorFromLambdaGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("accessPrivateInlineClassMethodFromCompanion.kt") public void testAccessPrivateInlineClassMethodFromCompanion() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromCompanion.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("accessPrivateInlineClassMethodFromCompanion2.kt") public void testAccessPrivateInlineClassMethodFromCompanion2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromCompanion2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("accessPrivateInlineClassMethodFromCompanion2Generic.kt") public void testAccessPrivateInlineClassMethodFromCompanion2Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromCompanion2Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("accessPrivateInlineClassMethodFromCompanionGeneric.kt") public void testAccessPrivateInlineClassMethodFromCompanionGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromCompanionGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("accessPrivateInlineClassMethodFromInlineLambda.kt") public void testAccessPrivateInlineClassMethodFromInlineLambda() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromInlineLambda.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("accessPrivateInlineClassMethodFromInlineLambda2.kt") public void testAccessPrivateInlineClassMethodFromInlineLambda2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromInlineLambda2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("accessPrivateInlineClassMethodFromInlineLambda2Generic.kt") public void testAccessPrivateInlineClassMethodFromInlineLambda2Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromInlineLambda2Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("accessPrivateInlineClassMethodFromInlineLambdaGeneric.kt") public void testAccessPrivateInlineClassMethodFromInlineLambdaGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromInlineLambdaGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("accessPrivateInlineClassMethodFromLambda.kt") public void testAccessPrivateInlineClassMethodFromLambda() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromLambda.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("accessPrivateInlineClassMethodFromLambda2.kt") public void testAccessPrivateInlineClassMethodFromLambda2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromLambda2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("accessPrivateInlineClassMethodFromLambda2Generic.kt") public void testAccessPrivateInlineClassMethodFromLambda2Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromLambda2Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("accessPrivateInlineClassMethodFromLambdaGeneric.kt") public void testAccessPrivateInlineClassMethodFromLambdaGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromLambdaGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test public void testAllFilesPresentInContextsAndAccessors() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("captureInlineClassInstanceInLambda.kt") public void testCaptureInlineClassInstanceInLambda() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInLambda.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("captureInlineClassInstanceInLambda2.kt") public void testCaptureInlineClassInstanceInLambda2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInLambda2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("captureInlineClassInstanceInLambda2Generic.kt") public void testCaptureInlineClassInstanceInLambda2Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInLambda2Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("captureInlineClassInstanceInLambdaGeneric.kt") public void testCaptureInlineClassInstanceInLambdaGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInLambdaGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("captureInlineClassInstanceInObject.kt") public void testCaptureInlineClassInstanceInObject() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInObject.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("captureInlineClassInstanceInObjectGeneric.kt") public void testCaptureInlineClassInstanceInObjectGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInObjectGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineLambdaInInlineClassFun.kt") public void testInlineLambdaInInlineClassFun() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/inlineLambdaInInlineClassFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineLambdaInInlineClassFunGeneric.kt") public void testInlineLambdaInInlineClassFunGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/inlineLambdaInInlineClassFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt26858.kt") public void testKt26858() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt26858.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt26858Generic.kt") public void testKt26858Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt26858Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27513.kt") public void testKt27513() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt27513.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27513Generic.kt") public void testKt27513Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt27513Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt30780.kt") public void testKt30780() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt30780.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt30780Generic.kt") public void testKt30780Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt30780Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("lambdaInInlineClassFun.kt") public void testLambdaInInlineClassFun() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/lambdaInInlineClassFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("lambdaInInlineClassFunGeneric.kt") public void testLambdaInInlineClassFunGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/lambdaInInlineClassFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("objectInInlineClassFun.kt") public void testObjectInInlineClassFun() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/objectInInlineClassFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("objectInInlineClassFunGeneric.kt") public void testObjectInInlineClassFunGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/objectInInlineClassFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("toPrivateCompanionFun.kt") public void testToPrivateCompanionFun() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/toPrivateCompanionFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("toPrivateCompanionFunGeneric.kt") public void testToPrivateCompanionFunGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/toPrivateCompanionFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("toPrivateCompanionVal.kt") public void testToPrivateCompanionVal() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/toPrivateCompanionVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("toPrivateCompanionValGeneric.kt") public void testToPrivateCompanionValGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/toPrivateCompanionValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/defaultParameterValues") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DefaultParameterValues extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - - private void runTest(String testDataFilePath, java.util.function.Function transformer) throws Exception { - KotlinTestUtils.runTest0(path -> doTestWithTransformer(path, transformer), TargetBackend.WASM, testDataFilePath); - } - + public class DefaultParameterValues { + @Test public void testAllFilesPresentInDefaultParameterValues() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("defaultConstructorParameterValuesOfInlineClassType.kt") public void testDefaultConstructorParameterValuesOfInlineClassType() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultConstructorParameterValuesOfInlineClassType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("defaultConstructorParameterValuesOfInlineClassTypeGeneric.kt") public void testDefaultConstructorParameterValuesOfInlineClassTypeGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultConstructorParameterValuesOfInlineClassTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("defaultInterfaceFunParameterValuesOfInlineClassType.kt") public void testDefaultInterfaceFunParameterValuesOfInlineClassType() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultInterfaceFunParameterValuesOfInlineClassType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("defaultInterfaceFunParameterValuesOfInlineClassTypeGeneric.kt") public void testDefaultInterfaceFunParameterValuesOfInlineClassTypeGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultInterfaceFunParameterValuesOfInlineClassTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("defaultParameterValuesOfInlineClassType.kt") public void testDefaultParameterValuesOfInlineClassType() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultParameterValuesOfInlineClassType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("defaultParameterValuesOfInlineClassTypeBoxing.kt") public void testDefaultParameterValuesOfInlineClassTypeBoxing() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultParameterValuesOfInlineClassTypeBoxing.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("defaultParameterValuesOfInlineClassTypeBoxingGeneric.kt") public void testDefaultParameterValuesOfInlineClassTypeBoxingGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultParameterValuesOfInlineClassTypeBoxingGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("defaultParameterValuesOfInlineClassTypeGeneric.kt") public void testDefaultParameterValuesOfInlineClassTypeGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultParameterValuesOfInlineClassTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("defaultValueOfInlineClassTypeInInlineFun.kt") public void testDefaultValueOfInlineClassTypeInInlineFun() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultValueOfInlineClassTypeInInlineFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("defaultValueOfInlineClassTypeInInlineFunGeneric.kt") public void testDefaultValueOfInlineClassTypeInInlineFunGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultValueOfInlineClassTypeInInlineFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("defaultValueOfInlineClassTypeInInlineFunInInlineClass.kt") public void testDefaultValueOfInlineClassTypeInInlineFunInInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultValueOfInlineClassTypeInInlineFunInInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("defaultValueOfInlineClassTypeInInlineFunInInlineClassGeneric.kt") public void testDefaultValueOfInlineClassTypeInInlineFunInInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultValueOfInlineClassTypeInInlineFunInInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassFun.kt") public void testInlineClassFun() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/inlineClassFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassFunGeneric.kt") public void testInlineClassFunGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/inlineClassFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassPrimaryConstructor.kt") public void testInlineClassPrimaryConstructor() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/inlineClassPrimaryConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassPrimaryConstructorGeneric.kt") public void testInlineClassPrimaryConstructorGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/inlineClassPrimaryConstructorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassPrimaryConstructorWithInlineClassValue.kt") public void testInlineClassPrimaryConstructorWithInlineClassValue() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/inlineClassPrimaryConstructorWithInlineClassValue.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassPrimaryConstructorWithInlineClassValueGeneric.kt") public void testInlineClassPrimaryConstructorWithInlineClassValueGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/inlineClassPrimaryConstructorWithInlineClassValueGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassSecondaryConstructor.kt") public void testInlineClassSecondaryConstructor() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/inlineClassSecondaryConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineClassSecondaryConstructorGeneric.kt") public void testInlineClassSecondaryConstructorGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/inlineClassSecondaryConstructorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt26554.kt") public void testKt26554() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/kt26554.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27416.kt") public void testKt27416() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/kt27416.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27416Generic.kt") public void testKt27416Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/kt27416Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultWithDefaultParameter") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DefaultWithDefaultParameter extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DefaultWithDefaultParameter { + @Test public void testAllFilesPresentInDefaultWithDefaultParameter() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultWithDefaultParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class OverrideFunctionWithDefaultParameter extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class OverrideFunctionWithDefaultParameter { + @Test public void testAllFilesPresentInOverrideFunctionWithDefaultParameter() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/delegationByUnderlyingType") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DelegationByUnderlyingType extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DelegationByUnderlyingType { + @Test public void testAllFilesPresentInDelegationByUnderlyingType() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/delegationByUnderlyingType"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("default.kt") public void testDefault() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/delegationByUnderlyingType/default.kt"); } + @Test @TestMetadata("defaultArgument.kt") public void testDefaultArgument() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/delegationByUnderlyingType/defaultArgument.kt"); } + @Test @TestMetadata("defaultArgumentGeneric.kt") public void testDefaultArgumentGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/delegationByUnderlyingType/defaultArgumentGeneric.kt"); } + @Test @TestMetadata("defaultGeneric.kt") public void testDefaultGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/delegationByUnderlyingType/defaultGeneric.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/delegationByUnderlyingType/simple.kt"); } + @Test @TestMetadata("simpleGeneric.kt") public void testSimpleGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/delegationByUnderlyingType/simpleGeneric.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/funInterface") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class FunInterface extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - - private void runTest(String testDataFilePath, java.util.function.Function transformer) throws Exception { - KotlinTestUtils.runTest0(path -> doTestWithTransformer(path, transformer), TargetBackend.WASM, testDataFilePath); - } - + public class FunInterface { + @Test public void testAllFilesPresentInFunInterface() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/funInterface"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("argumentIC.kt") public void testArgumentIC() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/funInterface/argumentIC.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("argumentICGeneric.kt") public void testArgumentICGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/funInterface/argumentICGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("argumentICGeneric2.kt") public void testArgumentICGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/funInterface/argumentICGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("argumentResult.kt") public void testArgumentResult() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/funInterface/argumentResult.kt"); } + @Test @TestMetadata("kt51121.kt") public void testKt51121() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/funInterface/kt51121.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt51121_2.kt") public void testKt51121_2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/funInterface/kt51121_2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("mangledSamWrappers.kt") public void testMangledSamWrappers() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/funInterface/mangledSamWrappers.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("mangledSamWrappersGeneric.kt") public void testMangledSamWrappersGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/funInterface/mangledSamWrappersGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("returnIC.kt") public void testReturnIC() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/funInterface/returnIC.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("returnICGeneric.kt") public void testReturnICGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/funInterface/returnICGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("returnICGeneric2.kt") public void testReturnICGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/funInterface/returnICGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("returnResult.kt") public void testReturnResult() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/funInterface/returnResult.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/functionNameMangling") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class FunctionNameMangling extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - - private void runTest(String testDataFilePath, java.util.function.Function transformer) throws Exception { - KotlinTestUtils.runTest0(path -> doTestWithTransformer(path, transformer), TargetBackend.WASM, testDataFilePath); - } - + public class FunctionNameMangling { + @Test public void testAllFilesPresentInFunctionNameMangling() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/functionNameMangling"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("anonymousObjectInFunctionWithMangledName.kt") public void testAnonymousObjectInFunctionWithMangledName() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/anonymousObjectInFunctionWithMangledName.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("anonymousObjectInFunctionWithMangledNameGeneric.kt") public void testAnonymousObjectInFunctionWithMangledNameGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/anonymousObjectInFunctionWithMangledNameGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("extensionFunctionsDoNotClash.kt") public void testExtensionFunctionsDoNotClash() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/extensionFunctionsDoNotClash.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("extensionFunctionsDoNotClashGeneric.kt") public void testExtensionFunctionsDoNotClashGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/extensionFunctionsDoNotClashGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("functionsWithDifferentNullabilityDoNotClash.kt") public void testFunctionsWithDifferentNullabilityDoNotClash() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/functionsWithDifferentNullabilityDoNotClash.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("functionsWithDifferentNullabilityDoNotClashGeneric.kt") public void testFunctionsWithDifferentNullabilityDoNotClashGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/functionsWithDifferentNullabilityDoNotClashGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("genericFunctionsDoNotClash.kt") public void testGenericFunctionsDoNotClash() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/genericFunctionsDoNotClash.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("genericFunctionsDoNotClashGeneric.kt") public void testGenericFunctionsDoNotClashGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/genericFunctionsDoNotClashGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("localClassInFunctionWithMangledName.kt") public void testLocalClassInFunctionWithMangledName() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/localClassInFunctionWithMangledName.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("localClassInFunctionWithMangledNameGeneric.kt") public void testLocalClassInFunctionWithMangledNameGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/localClassInFunctionWithMangledNameGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("mangledFunctionsCanBeOverridden.kt") public void testMangledFunctionsCanBeOverridden() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/mangledFunctionsCanBeOverridden.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("mangledFunctionsCanBeOverriddenGeneric.kt") public void testMangledFunctionsCanBeOverriddenGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/mangledFunctionsCanBeOverriddenGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("mangledFunctionsDoNotClash.kt") public void testMangledFunctionsDoNotClash() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/mangledFunctionsDoNotClash.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("mangledFunctionsDoNotClashGeneric.kt") public void testMangledFunctionsDoNotClashGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/mangledFunctionsDoNotClashGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("mangledFunctionsPresentInStackTrace.kt") public void testMangledFunctionsPresentInStackTrace() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/mangledFunctionsPresentInStackTrace.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("mangledFunctionsPresentInStackTraceGeneric.kt") public void testMangledFunctionsPresentInStackTraceGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/mangledFunctionsPresentInStackTraceGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("mixedSignatureFunctionsDoNotClash.kt") public void testMixedSignatureFunctionsDoNotClash() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/mixedSignatureFunctionsDoNotClash.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("mixedSignatureFunctionsDoNotClashGeneric.kt") public void testMixedSignatureFunctionsDoNotClashGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/mixedSignatureFunctionsDoNotClashGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overridingMethodInGenericClass.kt") public void testOverridingMethodInGenericClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/overridingMethodInGenericClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overridingMethodInGenericClass2.kt") public void testOverridingMethodInGenericClass2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/overridingMethodInGenericClass2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overridingMethodInGenericClass2Generic.kt") public void testOverridingMethodInGenericClass2Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/overridingMethodInGenericClass2Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overridingMethodInGenericClassGeneric.kt") public void testOverridingMethodInGenericClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/overridingMethodInGenericClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("propertySetterWithInlineClassTypeArgument.kt") public void testPropertySetterWithInlineClassTypeArgument() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/propertySetterWithInlineClassTypeArgument.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("propertySetterWithInlineClassTypeArgumentGeneric.kt") public void testPropertySetterWithInlineClassTypeArgumentGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/propertySetterWithInlineClassTypeArgumentGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("reflectionForFunctionWithMangledName.kt") public void testReflectionForFunctionWithMangledName() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/reflectionForFunctionWithMangledName.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("reflectionForFunctionWithMangledNameGeneric.kt") public void testReflectionForFunctionWithMangledNameGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/reflectionForFunctionWithMangledNameGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("reflectionForPropertyOfInlineClassType.kt") public void testReflectionForPropertyOfInlineClassType() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/reflectionForPropertyOfInlineClassType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("reflectionForPropertyOfInlineClassTypeGeneric.kt") public void testReflectionForPropertyOfInlineClassTypeGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/reflectionForPropertyOfInlineClassTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("syntheticAccessorForFunctionWithMangledName.kt") public void testSyntheticAccessorForFunctionWithMangledName() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/syntheticAccessorForFunctionWithMangledName.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("syntheticAccessorForFunctionWithMangledNameGeneric.kt") public void testSyntheticAccessorForFunctionWithMangledNameGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/syntheticAccessorForFunctionWithMangledNameGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("syntheticAccessorsForPropertyOfInlineClassType.kt") public void testSyntheticAccessorsForPropertyOfInlineClassType() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/syntheticAccessorsForPropertyOfInlineClassType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("syntheticAccessorsForPropertyOfInlineClassTypeGeneric.kt") public void testSyntheticAccessorsForPropertyOfInlineClassTypeGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/syntheticAccessorsForPropertyOfInlineClassTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/genericUnderlyingValue") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class GenericUnderlyingValue extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class GenericUnderlyingValue { + @Test public void testAllFilesPresentInGenericUnderlyingValue() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/genericUnderlyingValue"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("array.kt") public void testArray() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/genericUnderlyingValue/array.kt"); } + @Test @TestMetadata("arrayIC.kt") public void testArrayIC() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/genericUnderlyingValue/arrayIC.kt"); } + @Test @TestMetadata("primitive.kt") public void testPrimitive() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/genericUnderlyingValue/primitive.kt"); } + @Test @TestMetadata("recursive.kt") public void testRecursive() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/genericUnderlyingValue/recursive.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/genericUnderlyingValue/simple.kt"); } + @Test @TestMetadata("simple2.kt") public void testSimple2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/genericUnderlyingValue/simple2.kt"); } + @Test @TestMetadata("upperBound.kt") public void testUpperBound() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/genericUnderlyingValue/upperBound.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/hiddenConstructor") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class HiddenConstructor extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - - private void runTest(String testDataFilePath, java.util.function.Function transformer) throws Exception { - KotlinTestUtils.runTest0(path -> doTestWithTransformer(path, transformer), TargetBackend.WASM, testDataFilePath); - } - + public class HiddenConstructor { + @Test public void testAllFilesPresentInHiddenConstructor() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/hiddenConstructor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("constructorReferencedFromOtherFile1.kt") public void testConstructorReferencedFromOtherFile1() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/constructorReferencedFromOtherFile1.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("constructorReferencedFromOtherFile1Generic.kt") public void testConstructorReferencedFromOtherFile1Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/constructorReferencedFromOtherFile1Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("constructorReferencedFromOtherFile2.kt") public void testConstructorReferencedFromOtherFile2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/constructorReferencedFromOtherFile2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("constructorReferencedFromOtherFile2Generic.kt") public void testConstructorReferencedFromOtherFile2Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/constructorReferencedFromOtherFile2Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("constructorWithDefaultParameters.kt") public void testConstructorWithDefaultParameters() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/constructorWithDefaultParameters.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("constructorWithDefaultParametersGeneric.kt") public void testConstructorWithDefaultParametersGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/constructorWithDefaultParametersGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("delegatingSuperConstructorCall.kt") public void testDelegatingSuperConstructorCall() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/delegatingSuperConstructorCall.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("delegatingSuperConstructorCallGeneric.kt") public void testDelegatingSuperConstructorCallGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/delegatingSuperConstructorCallGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("delegatingSuperConstructorCallInSecondaryConstructor.kt") public void testDelegatingSuperConstructorCallInSecondaryConstructor() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/delegatingSuperConstructorCallInSecondaryConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("delegatingSuperConstructorCallInSecondaryConstructorGeneric.kt") public void testDelegatingSuperConstructorCallInSecondaryConstructorGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/delegatingSuperConstructorCallInSecondaryConstructorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("delegatingThisConstructorCall.kt") public void testDelegatingThisConstructorCall() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/delegatingThisConstructorCall.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("delegatingThisConstructorCallGeneric.kt") public void testDelegatingThisConstructorCallGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/delegatingThisConstructorCallGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("enumClassConstructor.kt") public void testEnumClassConstructor() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/enumClassConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("enumClassConstructorGeneric.kt") public void testEnumClassConstructorGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/enumClassConstructorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("innerClassConstructor.kt") public void testInnerClassConstructor() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/innerClassConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("innerClassConstructorGeneric.kt") public void testInnerClassConstructorGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/innerClassConstructorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt28855.kt") public void testKt28855() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/kt28855.kt"); } + @Test @TestMetadata("primaryConstructor.kt") public void testPrimaryConstructor() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/primaryConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("primaryConstructorGeneric.kt") public void testPrimaryConstructorGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/primaryConstructorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("privateConstructor.kt") public void testPrivateConstructor() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/privateConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("privateConstructorGeneric.kt") public void testPrivateConstructorGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/privateConstructorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("sealedClassConstructor.kt") public void testSealedClassConstructor() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/sealedClassConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("sealedClassConstructorGeneric.kt") public void testSealedClassConstructorGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/sealedClassConstructorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("secondaryConstructor.kt") public void testSecondaryConstructor() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/secondaryConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("secondaryConstructorGeneric.kt") public void testSecondaryConstructorGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/secondaryConstructorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/inlineClassCollection") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class InlineClassCollection extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - - private void runTest(String testDataFilePath, java.util.function.Function transformer) throws Exception { - KotlinTestUtils.runTest0(path -> doTestWithTransformer(path, transformer), TargetBackend.WASM, testDataFilePath); - } - + public class InlineClassCollection { + @Test public void testAllFilesPresentInInlineClassCollection() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/inlineClassCollection"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("inlineCollectionOfInlineClass.kt") public void testInlineCollectionOfInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineCollectionOfInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineCollectionOfInlineClassGeneric.kt") public void testInlineCollectionOfInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineCollectionOfInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineListOfInlineClass.kt") public void testInlineListOfInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineListOfInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineListOfInlineClassGeneric.kt") public void testInlineListOfInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineListOfInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineMapOfInlineClass.kt") public void testInlineMapOfInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineMapOfInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineMapOfInlineClassGeneric.kt") public void testInlineMapOfInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineMapOfInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("inlineMutableCollectionBulkAdd.kt") public void testInlineMutableCollectionBulkAdd() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineMutableCollectionBulkAdd.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/interfaceDelegation") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class InterfaceDelegation extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - - private void runTest(String testDataFilePath, java.util.function.Function transformer) throws Exception { - KotlinTestUtils.runTest0(path -> doTestWithTransformer(path, transformer), TargetBackend.WASM, testDataFilePath); - } - + public class InterfaceDelegation { + @Test public void testAllFilesPresentInInterfaceDelegation() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceDelegation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("interfaceImplementationByDelegation.kt") public void testInterfaceImplementationByDelegation() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/interfaceImplementationByDelegation.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("interfaceImplementationByDelegationGeneric.kt") public void testInterfaceImplementationByDelegationGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/interfaceImplementationByDelegationGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt38337.kt") public void testKt38337() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/kt38337.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt38337Generic.kt") public void testKt38337Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/kt38337Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("memberExtValDelegationWithInlineClassParameterTypes.kt") public void testMemberExtValDelegationWithInlineClassParameterTypes() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtValDelegationWithInlineClassParameterTypes.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("memberExtValDelegationWithInlineClassParameterTypesGeneric.kt") public void testMemberExtValDelegationWithInlineClassParameterTypesGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtValDelegationWithInlineClassParameterTypesGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("memberExtVarDelegationWithInlineClassParameterTypes.kt") public void testMemberExtVarDelegationWithInlineClassParameterTypes() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtVarDelegationWithInlineClassParameterTypes.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("memberFunDelegatedToInlineClassInt.kt") public void testMemberFunDelegatedToInlineClassInt() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassInt.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("memberFunDelegatedToInlineClassIntGeneric.kt") public void testMemberFunDelegatedToInlineClassIntGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassIntGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("memberFunDelegatedToInlineClassLong.kt") public void testMemberFunDelegatedToInlineClassLong() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassLong.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("memberFunDelegatedToInlineClassLongGeneric.kt") public void testMemberFunDelegatedToInlineClassLongGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassLongGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("memberFunDelegationToInlineClassWithInlineClassParameterTypes.kt") public void testMemberFunDelegationToInlineClassWithInlineClassParameterTypes() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationToInlineClassWithInlineClassParameterTypes.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("memberFunDelegationToInlineClassWithInlineClassParameterTypesGeneric.kt") public void testMemberFunDelegationToInlineClassWithInlineClassParameterTypesGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationToInlineClassWithInlineClassParameterTypesGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("memberFunDelegationWithInlineClassParameterTypes.kt") public void testMemberFunDelegationWithInlineClassParameterTypes() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationWithInlineClassParameterTypes.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("memberFunDelegationWithInlineClassParameterTypesGeneric.kt") public void testMemberFunDelegationWithInlineClassParameterTypesGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationWithInlineClassParameterTypesGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class InterfaceMethodCalls extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - - private void runTest(String testDataFilePath, java.util.function.Function transformer) throws Exception { - KotlinTestUtils.runTest0(path -> doTestWithTransformer(path, transformer), TargetBackend.WASM, testDataFilePath); - } - + public class InterfaceMethodCalls { + @Test public void testAllFilesPresentInInterfaceMethodCalls() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("complexGenericMethodWithInlineClassOverride.kt") public void testComplexGenericMethodWithInlineClassOverride() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/complexGenericMethodWithInlineClassOverride.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("complexGenericMethodWithInlineClassOverride2.kt") public void testComplexGenericMethodWithInlineClassOverride2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/complexGenericMethodWithInlineClassOverride2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("complexGenericMethodWithInlineClassOverride2Generic.kt") public void testComplexGenericMethodWithInlineClassOverride2Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/complexGenericMethodWithInlineClassOverride2Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("complexGenericMethodWithInlineClassOverride3.kt") public void testComplexGenericMethodWithInlineClassOverride3() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/complexGenericMethodWithInlineClassOverride3.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("complexGenericMethodWithInlineClassOverride3Generic.kt") public void testComplexGenericMethodWithInlineClassOverride3Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/complexGenericMethodWithInlineClassOverride3Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("complexGenericMethodWithInlineClassOverrideGeneric.kt") public void testComplexGenericMethodWithInlineClassOverrideGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/complexGenericMethodWithInlineClassOverrideGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("defaultInterfaceExtensionFunCall.kt") public void testDefaultInterfaceExtensionFunCall() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/defaultInterfaceExtensionFunCall.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("defaultInterfaceExtensionFunCallGeneric.kt") public void testDefaultInterfaceExtensionFunCallGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/defaultInterfaceExtensionFunCallGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("defaultInterfaceMethodCall.kt") public void testDefaultInterfaceMethodCall() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/defaultInterfaceMethodCall.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("defaultInterfaceMethodCallGeneric.kt") public void testDefaultInterfaceMethodCallGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/defaultInterfaceMethodCallGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("genericDefaultInterfaceExtensionFunCall.kt") public void testGenericDefaultInterfaceExtensionFunCall() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/genericDefaultInterfaceExtensionFunCall.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("genericDefaultInterfaceExtensionFunCallGeneric.kt") public void testGenericDefaultInterfaceExtensionFunCallGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/genericDefaultInterfaceExtensionFunCallGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("genericDefaultInterfaceMethodCall.kt") public void testGenericDefaultInterfaceMethodCall() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/genericDefaultInterfaceMethodCall.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("genericDefaultInterfaceMethodCallGeneric.kt") public void testGenericDefaultInterfaceMethodCallGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/genericDefaultInterfaceMethodCallGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("genericInterfaceMethodCall.kt") public void testGenericInterfaceMethodCall() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/genericInterfaceMethodCall.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("genericInterfaceMethodCallGeneric.kt") public void testGenericInterfaceMethodCallGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/genericInterfaceMethodCallGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("genericMethodWithInlineClassOverride.kt") public void testGenericMethodWithInlineClassOverride() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/genericMethodWithInlineClassOverride.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("genericMethodWithInlineClassOverrideGeneric.kt") public void testGenericMethodWithInlineClassOverrideGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/genericMethodWithInlineClassOverrideGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("interfaceSuperCall.kt") public void testInterfaceSuperCall() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/interfaceSuperCall.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("interfaceSuperCallGeneric.kt") public void testInterfaceSuperCallGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/interfaceSuperCallGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overriddenDefaultInterfaceMethodCall.kt") public void testOverriddenDefaultInterfaceMethodCall() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/overriddenDefaultInterfaceMethodCall.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("overriddenDefaultInterfaceMethodCallGeneric.kt") public void testOverriddenDefaultInterfaceMethodCallGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/overriddenDefaultInterfaceMethodCallGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/javaInterop") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class JavaInterop extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class JavaInterop { + @Test public void testAllFilesPresentInJavaInterop() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/javaInterop"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Jvm8DefaultInterfaceMethods extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Jvm8DefaultInterfaceMethods { + @Test public void testAllFilesPresentInJvm8DefaultInterfaceMethods() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/propertyDelegation") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class PropertyDelegation extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - - private void runTest(String testDataFilePath, java.util.function.Function transformer) throws Exception { - KotlinTestUtils.runTest0(path -> doTestWithTransformer(path, transformer), TargetBackend.WASM, testDataFilePath); - } - + public class PropertyDelegation { + @Test public void testAllFilesPresentInPropertyDelegation() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/propertyDelegation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("captureLocalVarDelegatedToInlineClass.kt") public void testCaptureLocalVarDelegatedToInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/captureLocalVarDelegatedToInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("captureLocalVarDelegatedToInlineClassGeneric.kt") public void testCaptureLocalVarDelegatedToInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/captureLocalVarDelegatedToInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("delegateClassVarToInlineClass.kt") public void testDelegateClassVarToInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateClassVarToInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("delegateClassVarToInlineClassGeneric.kt") public void testDelegateClassVarToInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateClassVarToInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("delegateClassVarToInlineClassWithProvideDelegate.kt") public void testDelegateClassVarToInlineClassWithProvideDelegate() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateClassVarToInlineClassWithProvideDelegate.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("delegateClassVarToInlineClassWithProvideDelegateGeneric.kt") public void testDelegateClassVarToInlineClassWithProvideDelegateGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateClassVarToInlineClassWithProvideDelegateGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("delegateCompanionVarToInlineClass.kt") public void testDelegateCompanionVarToInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateCompanionVarToInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("delegateCompanionVarToInlineClassGeneric.kt") public void testDelegateCompanionVarToInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateCompanionVarToInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("delegateLocalVarToInlineClass.kt") public void testDelegateLocalVarToInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateLocalVarToInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("delegateLocalVarToInlineClassGeneric.kt") public void testDelegateLocalVarToInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateLocalVarToInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("delegateObjectVarToInlineClass.kt") public void testDelegateObjectVarToInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateObjectVarToInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("delegateObjectVarToInlineClassGeneric.kt") public void testDelegateObjectVarToInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateObjectVarToInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("delegatePrivateCompanionVarToInlineClass.kt") public void testDelegatePrivateCompanionVarToInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegatePrivateCompanionVarToInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("delegatePrivateCompanionVarToInlineClassGeneric.kt") public void testDelegatePrivateCompanionVarToInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegatePrivateCompanionVarToInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("delegateTopLevelVarToInlineClass.kt") public void testDelegateTopLevelVarToInlineClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateTopLevelVarToInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("delegateTopLevelVarToInlineClassGeneric.kt") public void testDelegateTopLevelVarToInlineClassGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateTopLevelVarToInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("delegatedPropertyOfInlineClassType.kt") public void testDelegatedPropertyOfInlineClassType() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegatedPropertyOfInlineClassType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("delegatedPropertyOfInlineClassTypeGeneric.kt") public void testDelegatedPropertyOfInlineClassTypeGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegatedPropertyOfInlineClassTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27070.kt") public void testKt27070() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/kt27070.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt27070Generic.kt") public void testKt27070Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/kt27070Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt42933.kt") public void testKt42933() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/kt42933.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("kt42933Generic.kt") public void testKt42933Generic() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/kt42933Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/result") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Result extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Result { + @Test public void testAllFilesPresentInResult() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/result"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("directCall1.kt") public void testDirectCall1() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/result/directCall1.kt"); } + @Test @TestMetadata("directCall2.kt") public void testDirectCall2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/result/directCall2.kt"); } + @Test @TestMetadata("doubleOverride.kt") public void testDoubleOverride() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/result/doubleOverride.kt"); } + @Test @TestMetadata("extensionOverride.kt") public void testExtensionOverride() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/result/extensionOverride.kt"); } + @Test @TestMetadata("inlineMethodOnResult.kt") public void testInlineMethodOnResult() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/result/inlineMethodOnResult.kt"); } + @Test @TestMetadata("lambdaTakesResultThroughBridge.kt") public void testLambdaTakesResultThroughBridge() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/result/lambdaTakesResultThroughBridge.kt"); } + @Test @TestMetadata("returnGenericMultiModule.kt") public void testReturnGenericMultiModule() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/result/returnGenericMultiModule.kt"); } + @Test @TestMetadata("returnGenericSingleModule.kt") public void testReturnGenericSingleModule() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/result/returnGenericSingleModule.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/returnResult") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ReturnResult extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ReturnResult { + @Test public void testAllFilesPresentInReturnResult() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/returnResult"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("class.kt") public void testClass() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/returnResult/class.kt"); } + @Test @TestMetadata("classAnyOverride.kt") public void testClassAnyOverride() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/returnResult/classAnyOverride.kt"); } + @Test @TestMetadata("classGenericOverride.kt") public void testClassGenericOverride() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/returnResult/classGenericOverride.kt"); } + @Test @TestMetadata("classResultOverride.kt") public void testClassResultOverride() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/returnResult/classResultOverride.kt"); } + @Test @TestMetadata("interface.kt") public void testInterface() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/returnResult/interface.kt"); } + @Test @TestMetadata("topLevel.kt") public void testTopLevel() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/returnResult/topLevel.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class UnboxGenericParameter extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class UnboxGenericParameter { + @Test public void testAllFilesPresentInUnboxGenericParameter() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class FunInterface extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - - private void runTest(String testDataFilePath, java.util.function.Function transformer) throws Exception { - KotlinTestUtils.runTest0(path -> doTestWithTransformer(path, transformer), TargetBackend.WASM, testDataFilePath); - } - + public class FunInterface { + @Test public void testAllFilesPresentInFunInterface() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("any.kt") public void testAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/any.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("anyGeneric.kt") public void testAnyGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/anyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("anyN.kt") public void testAnyN() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/anyN.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("anyNGeneric.kt") public void testAnyNGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/anyNGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("anyNGeneric2.kt") public void testAnyNGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/anyNGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("iface.kt") public void testIface() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/iface.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("ifaceChild.kt") public void testIfaceChild() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/ifaceChild.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("ifaceChildGeneric.kt") public void testIfaceChildGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/ifaceChildGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("ifaceGeneric.kt") public void testIfaceGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/ifaceGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("nullableResult.kt") public void testNullableResult() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/nullableResult.kt"); } + @Test @TestMetadata("primitive.kt") public void testPrimitive() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/primitive.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("primitiveGeneric.kt") public void testPrimitiveGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/primitiveGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("result.kt") public void testResult() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/result.kt"); } + @Test @TestMetadata("resultAny.kt") public void testResultAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/resultAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("resultAnyGeneric.kt") public void testResultAnyGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/resultAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("string.kt") public void testString() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/string.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("stringGeneric.kt") public void testStringGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/stringGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Lambda extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - - private void runTest(String testDataFilePath, java.util.function.Function transformer) throws Exception { - KotlinTestUtils.runTest0(path -> doTestWithTransformer(path, transformer), TargetBackend.WASM, testDataFilePath); - } - + public class Lambda { + @Test public void testAllFilesPresentInLambda() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("any.kt") public void testAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/any.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("anyGeneric.kt") public void testAnyGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/anyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("anyN.kt") public void testAnyN() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/anyN.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("anyNGeneric.kt") public void testAnyNGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/anyNGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("anyNGeneric2.kt") public void testAnyNGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/anyNGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("iface.kt") public void testIface() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/iface.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("ifaceChild.kt") public void testIfaceChild() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/ifaceChild.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("ifaceChildGeneric.kt") public void testIfaceChildGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/ifaceChildGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("ifaceGeneric.kt") public void testIfaceGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/ifaceGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("nullableResult.kt") public void testNullableResult() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/nullableResult.kt"); } + @Test @TestMetadata("primitive.kt") public void testPrimitive() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/primitive.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("primitiveGeneric.kt") public void testPrimitiveGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/primitiveGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("result.kt") public void testResult() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/result.kt"); } + @Test @TestMetadata("resultAny.kt") public void testResultAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/resultAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("resultAnyGeneric.kt") public void testResultAnyGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/resultAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("string.kt") public void testString() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/string.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("stringGeneric.kt") public void testStringGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/stringGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } } + @Nested @TestMetadata("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ObjectLiteral extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - - private void runTest(String testDataFilePath, java.util.function.Function transformer) throws Exception { - KotlinTestUtils.runTest0(path -> doTestWithTransformer(path, transformer), TargetBackend.WASM, testDataFilePath); - } - + public class ObjectLiteral { + @Test public void testAllFilesPresentInObjectLiteral() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("any.kt") public void testAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/any.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("anyGeneric.kt") public void testAnyGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/anyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("anyN.kt") public void testAnyN() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/anyN.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("anyNGeneric.kt") public void testAnyNGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/anyNGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("anyNGeneric2.kt") public void testAnyNGeneric2() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/anyNGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("iface.kt") public void testIface() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/iface.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("ifaceChild.kt") public void testIfaceChild() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/ifaceChild.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("ifaceChildGeneric.kt") public void testIfaceChildGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/ifaceChildGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("ifaceGeneric.kt") public void testIfaceGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/ifaceGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("nullableResult.kt") public void testNullableResult() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/nullableResult.kt"); } + @Test @TestMetadata("primitive.kt") public void testPrimitive() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/primitive.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("primitiveGeneric.kt") public void testPrimitiveGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/primitiveGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("result.kt") public void testResult() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/result.kt"); } + @Test @TestMetadata("resultAny.kt") public void testResultAny() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/resultAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("resultAnyGeneric.kt") public void testResultAnyGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/resultAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("string.kt") public void testString() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/string.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); } + @Test @TestMetadata("stringGeneric.kt") public void testStringGeneric() throws Exception { runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/stringGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); @@ -18077,270 +20474,313 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/innerNested") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class InnerNested extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class InnerNested { + @Test public void testAllFilesPresentInInnerNested() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("considerPropertyInitValueFromNestedClass.kt") public void testConsiderPropertyInitValueFromNestedClass() throws Exception { runTest("compiler/testData/codegen/box/innerNested/considerPropertyInitValueFromNestedClass.kt"); } + @Test @TestMetadata("createNestedClass.kt") public void testCreateNestedClass() throws Exception { runTest("compiler/testData/codegen/box/innerNested/createNestedClass.kt"); } + @Test @TestMetadata("createdNestedInOuterMember.kt") public void testCreatedNestedInOuterMember() throws Exception { runTest("compiler/testData/codegen/box/innerNested/createdNestedInOuterMember.kt"); } + @Test @TestMetadata("extenderNestedClass.kt") public void testExtenderNestedClass() throws Exception { runTest("compiler/testData/codegen/box/innerNested/extenderNestedClass.kt"); } + @Test @TestMetadata("extensionFun.kt") public void testExtensionFun() throws Exception { runTest("compiler/testData/codegen/box/innerNested/extensionFun.kt"); } + @Test @TestMetadata("extensionToNested.kt") public void testExtensionToNested() throws Exception { runTest("compiler/testData/codegen/box/innerNested/extensionToNested.kt"); } + @Test @TestMetadata("importNestedClass.kt") public void testImportNestedClass() throws Exception { runTest("compiler/testData/codegen/box/innerNested/importNestedClass.kt"); } + @Test @TestMetadata("innerGeneric.kt") public void testInnerGeneric() throws Exception { runTest("compiler/testData/codegen/box/innerNested/innerGeneric.kt"); } + @Test @TestMetadata("innerImplicitParameter.kt") public void testInnerImplicitParameter() throws Exception { runTest("compiler/testData/codegen/box/innerNested/innerImplicitParameter.kt"); } + @Test @TestMetadata("innerLabeledThis.kt") public void testInnerLabeledThis() throws Exception { runTest("compiler/testData/codegen/box/innerNested/innerLabeledThis.kt"); } + @Test @TestMetadata("innerSimple.kt") public void testInnerSimple() throws Exception { runTest("compiler/testData/codegen/box/innerNested/innerSimple.kt"); } + @Test @TestMetadata("innerWithDefaultArgument.kt") public void testInnerWithDefaultArgument() throws Exception { runTest("compiler/testData/codegen/box/innerNested/innerWithDefaultArgument.kt"); } + @Test @TestMetadata("innerWithDefaultInner.kt") public void testInnerWithDefaultInner() throws Exception { runTest("compiler/testData/codegen/box/innerNested/innerWithDefaultInner.kt"); } + @Test @TestMetadata("kt3132.kt") public void testKt3132() throws Exception { runTest("compiler/testData/codegen/box/innerNested/kt3132.kt"); } + @Test @TestMetadata("kt3927.kt") public void testKt3927() throws Exception { runTest("compiler/testData/codegen/box/innerNested/kt3927.kt"); } + @Test @TestMetadata("kt46829.kt") public void testKt46829() throws Exception { runTest("compiler/testData/codegen/box/innerNested/kt46829.kt"); } + @Test @TestMetadata("kt5363.kt") public void testKt5363() throws Exception { runTest("compiler/testData/codegen/box/innerNested/kt5363.kt"); } + @Test @TestMetadata("kt6804.kt") public void testKt6804() throws Exception { runTest("compiler/testData/codegen/box/innerNested/kt6804.kt"); } + @Test @TestMetadata("nestedClassInObject.kt") public void testNestedClassInObject() throws Exception { runTest("compiler/testData/codegen/box/innerNested/nestedClassInObject.kt"); } + @Test @TestMetadata("nestedClassObject.kt") public void testNestedClassObject() throws Exception { runTest("compiler/testData/codegen/box/innerNested/nestedClassObject.kt"); } + @Test @TestMetadata("nestedEnumConstant.kt") public void testNestedEnumConstant() throws Exception { runTest("compiler/testData/codegen/box/innerNested/nestedEnumConstant.kt"); } + @Test @TestMetadata("nestedGeneric.kt") public void testNestedGeneric() throws Exception { runTest("compiler/testData/codegen/box/innerNested/nestedGeneric.kt"); } + @Test @TestMetadata("nestedInPackage.kt") public void testNestedInPackage() throws Exception { runTest("compiler/testData/codegen/box/innerNested/nestedInPackage.kt"); } + @Test @TestMetadata("nestedInnerClass.kt") public void testNestedInnerClass() throws Exception { runTest("compiler/testData/codegen/box/innerNested/nestedInnerClass.kt"); } + @Test @TestMetadata("nestedObjects.kt") public void testNestedObjects() throws Exception { runTest("compiler/testData/codegen/box/innerNested/nestedObjects.kt"); } + @Test @TestMetadata("nestedSimple.kt") public void testNestedSimple() throws Exception { runTest("compiler/testData/codegen/box/innerNested/nestedSimple.kt"); } + @Test @TestMetadata("passingOuterRef.kt") public void testPassingOuterRef() throws Exception { runTest("compiler/testData/codegen/box/innerNested/passingOuterRef.kt"); } + @Test @TestMetadata("protectedNestedClass.kt") public void testProtectedNestedClass() throws Exception { runTest("compiler/testData/codegen/box/innerNested/protectedNestedClass.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/innerNested/superConstructorCall") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SuperConstructorCall extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class SuperConstructorCall { + @Test public void testAllFilesPresentInSuperConstructorCall() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested/superConstructorCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("deepInnerHierarchy.kt") public void testDeepInnerHierarchy() throws Exception { runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/deepInnerHierarchy.kt"); } + @Test @TestMetadata("deepLocalHierarchy.kt") public void testDeepLocalHierarchy() throws Exception { runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/deepLocalHierarchy.kt"); } + @Test @TestMetadata("innerExtendsInnerViaSecondaryConstuctor.kt") public void testInnerExtendsInnerViaSecondaryConstuctor() throws Exception { runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/innerExtendsInnerViaSecondaryConstuctor.kt"); } + @Test @TestMetadata("innerExtendsInnerWithProperOuterCapture.kt") public void testInnerExtendsInnerWithProperOuterCapture() throws Exception { runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/innerExtendsInnerWithProperOuterCapture.kt"); } + @Test @TestMetadata("kt11833_1.kt") public void testKt11833_1() throws Exception { runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/kt11833_1.kt"); } + @Test @TestMetadata("kt11833_2.kt") public void testKt11833_2() throws Exception { runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/kt11833_2.kt"); } + @Test @TestMetadata("localClassOuterDiffersFromInnerOuter.kt") public void testLocalClassOuterDiffersFromInnerOuter() throws Exception { runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/localClassOuterDiffersFromInnerOuter.kt"); } + @Test @TestMetadata("localExtendsInner.kt") public void testLocalExtendsInner() throws Exception { runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/localExtendsInner.kt"); } + @Test @TestMetadata("localExtendsLocalWithClosure.kt") public void testLocalExtendsLocalWithClosure() throws Exception { runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/localExtendsLocalWithClosure.kt"); } + @Test @TestMetadata("localWithClosureExtendsLocalWithClosure.kt") public void testLocalWithClosureExtendsLocalWithClosure() throws Exception { runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/localWithClosureExtendsLocalWithClosure.kt"); } + @Test @TestMetadata("objectExtendsClassDefaultArgument.kt") public void testObjectExtendsClassDefaultArgument() throws Exception { runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/objectExtendsClassDefaultArgument.kt"); } + @Test @TestMetadata("objectExtendsClassVararg.kt") public void testObjectExtendsClassVararg() throws Exception { runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/objectExtendsClassVararg.kt"); } + @Test @TestMetadata("objectExtendsInner.kt") public void testObjectExtendsInner() throws Exception { runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/objectExtendsInner.kt"); } + @Test @TestMetadata("objectExtendsInnerDefaultArgument.kt") public void testObjectExtendsInnerDefaultArgument() throws Exception { runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/objectExtendsInnerDefaultArgument.kt"); } + @Test @TestMetadata("objectExtendsInnerOfLocalVarargAndDefault.kt") public void testObjectExtendsInnerOfLocalVarargAndDefault() throws Exception { runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/objectExtendsInnerOfLocalVarargAndDefault.kt"); } + @Test @TestMetadata("objectExtendsInnerOfLocalWithCapture.kt") public void testObjectExtendsInnerOfLocalWithCapture() throws Exception { runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/objectExtendsInnerOfLocalWithCapture.kt"); } + @Test @TestMetadata("objectExtendsInnerWithDelegatingConstructor.kt") public void testObjectExtendsInnerWithDelegatingConstructor() throws Exception { runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/objectExtendsInnerWithDelegatingConstructor.kt"); } + @Test @TestMetadata("objectExtendsLocalCaptureInSuperCall.kt") public void testObjectExtendsLocalCaptureInSuperCall() throws Exception { runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/objectExtendsLocalCaptureInSuperCall.kt"); } + @Test @TestMetadata("objectExtendsLocalWithClosure.kt") public void testObjectExtendsLocalWithClosure() throws Exception { runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/objectExtendsLocalWithClosure.kt"); } + @Test @TestMetadata("objectExtendsLocal_kt16858.kt") public void testObjectExtendsLocal_kt16858() throws Exception { runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/objectExtendsLocal_kt16858.kt"); } + @Test @TestMetadata("objectOuterDiffersFromInnerOuter.kt") public void testObjectOuterDiffersFromInnerOuter() throws Exception { runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/objectOuterDiffersFromInnerOuter.kt"); @@ -18348,35 +20788,31 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/instructions") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Instructions extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Instructions { + @Test public void testAllFilesPresentInInstructions() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/instructions/swap") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Swap extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Swap { + @Test public void testAllFilesPresentInSwap() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions/swap"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("swapRefToSharedVarInt.kt") public void testSwapRefToSharedVarInt() throws Exception { runTest("compiler/testData/codegen/box/instructions/swap/swapRefToSharedVarInt.kt"); } + @Test @TestMetadata("swapRefToSharedVarLong.kt") public void testSwapRefToSharedVarLong() throws Exception { runTest("compiler/testData/codegen/box/instructions/swap/swapRefToSharedVarLong.kt"); @@ -18384,599 +20820,607 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/intrinsics") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Intrinsics extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Intrinsics { + @Test public void testAllFilesPresentInIntrinsics() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/intrinsics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("charToInt.kt") public void testCharToInt() throws Exception { runTest("compiler/testData/codegen/box/intrinsics/charToInt.kt"); } + @Test @TestMetadata("ea35953.kt") public void testEa35953() throws Exception { runTest("compiler/testData/codegen/box/intrinsics/ea35953.kt"); } + @Test @TestMetadata("incWithLabel.kt") public void testIncWithLabel() throws Exception { runTest("compiler/testData/codegen/box/intrinsics/incWithLabel.kt"); } + @Test @TestMetadata("kt10131.kt") public void testKt10131() throws Exception { runTest("compiler/testData/codegen/box/intrinsics/kt10131.kt"); } + @Test @TestMetadata("kt10131a.kt") public void testKt10131a() throws Exception { runTest("compiler/testData/codegen/box/intrinsics/kt10131a.kt"); } + @Test @TestMetadata("kt12125.kt") public void testKt12125() throws Exception { runTest("compiler/testData/codegen/box/intrinsics/kt12125.kt"); } + @Test @TestMetadata("kt12125_2.kt") public void testKt12125_2() throws Exception { runTest("compiler/testData/codegen/box/intrinsics/kt12125_2.kt"); } + @Test @TestMetadata("kt12125_inc.kt") public void testKt12125_inc() throws Exception { runTest("compiler/testData/codegen/box/intrinsics/kt12125_inc.kt"); } + @Test @TestMetadata("kt12125_inc_2.kt") public void testKt12125_inc_2() throws Exception { runTest("compiler/testData/codegen/box/intrinsics/kt12125_inc_2.kt"); } + @Test @TestMetadata("kt52163_boolean.kt") public void testKt52163_boolean() throws Exception { runTest("compiler/testData/codegen/box/intrinsics/kt52163_boolean.kt"); } + @Test @TestMetadata("kt52163_doubleCompareToInt.kt") public void testKt52163_doubleCompareToInt() throws Exception { runTest("compiler/testData/codegen/box/intrinsics/kt52163_doubleCompareToInt.kt"); } + @Test @TestMetadata("kt8666.kt") public void testKt8666() throws Exception { runTest("compiler/testData/codegen/box/intrinsics/kt8666.kt"); } + @Test @TestMetadata("longRangeWithExplicitDot.kt") public void testLongRangeWithExplicitDot() throws Exception { runTest("compiler/testData/codegen/box/intrinsics/longRangeWithExplicitDot.kt"); } + @Test @TestMetadata("nonShortCircuitAnd.kt") public void testNonShortCircuitAnd() throws Exception { runTest("compiler/testData/codegen/box/intrinsics/nonShortCircuitAnd.kt"); } + @Test @TestMetadata("nullPlusString.kt") public void testNullPlusString() throws Exception { runTest("compiler/testData/codegen/box/intrinsics/nullPlusString.kt"); } + @Test @TestMetadata("prefixIncDec.kt") public void testPrefixIncDec() throws Exception { runTest("compiler/testData/codegen/box/intrinsics/prefixIncDec.kt"); } + @Test @TestMetadata("rangeFromCollection.kt") public void testRangeFromCollection() throws Exception { runTest("compiler/testData/codegen/box/intrinsics/rangeFromCollection.kt"); } + @Test @TestMetadata("stringFromCollection.kt") public void testStringFromCollection() throws Exception { runTest("compiler/testData/codegen/box/intrinsics/stringFromCollection.kt"); } + @Test @TestMetadata("throwableParamOrder.kt") public void testThrowableParamOrder() throws Exception { runTest("compiler/testData/codegen/box/intrinsics/throwableParamOrder.kt"); } + @Test @TestMetadata("tostring.kt") public void testTostring() throws Exception { runTest("compiler/testData/codegen/box/intrinsics/tostring.kt"); } + @Test @TestMetadata("trimMarginWithBlankString.kt") public void testTrimMarginWithBlankString() throws Exception { runTest("compiler/testData/codegen/box/intrinsics/trimMarginWithBlankString.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/invokedynamic") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Invokedynamic extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Invokedynamic { + @Test public void testAllFilesPresentInInvokedynamic() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/invokedynamic"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/invokedynamic/lambdas") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Lambdas extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Lambdas { + @Test public void testAllFilesPresentInLambdas() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/invokedynamic/lambdas"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt52875.kt") public void testKt52875() throws Exception { runTest("compiler/testData/codegen/box/invokedynamic/lambdas/kt52875.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/invokedynamic/lambdas/inlineClassInSignature") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class InlineClassInSignature extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class InlineClassInSignature { + @Test public void testAllFilesPresentInInlineClassInSignature() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/invokedynamic/lambdas/inlineClassInSignature"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/invokedynamic/sam") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Sam extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Sam { + @Test public void testAllFilesPresentInSam() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/invokedynamic/sam"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/invokedynamic/sam/functionExprToJavaInterface") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class FunctionExprToJavaInterface extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class FunctionExprToJavaInterface { + @Test public void testAllFilesPresentInFunctionExprToJavaInterface() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/invokedynamic/sam/functionExprToJavaInterface"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/invokedynamic/sam/functionRefToJavaInterface") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class FunctionRefToJavaInterface extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class FunctionRefToJavaInterface { + @Test public void testAllFilesPresentInFunctionRefToJavaInterface() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/invokedynamic/sam/functionRefToJavaInterface"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/invokedynamic/sam/functionRefToJavaInterface/specialFunctions") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SpecialFunctions extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class SpecialFunctions { + @Test public void testAllFilesPresentInSpecialFunctions() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/invokedynamic/sam/functionRefToJavaInterface/specialFunctions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/invokedynamic/sam/functionRefToJavaInterface/withAccessor") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class WithAccessor extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class WithAccessor { + @Test public void testAllFilesPresentInWithAccessor() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/invokedynamic/sam/functionRefToJavaInterface/withAccessor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/invokedynamic/sam/inlineClassInSignature") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class InlineClassInSignature extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class InlineClassInSignature { + @Test public void testAllFilesPresentInInlineClassInSignature() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/invokedynamic/sam/inlineClassInSignature"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/invokedynamic/sam/specializedGenerics") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SpecializedGenerics extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class SpecializedGenerics { + @Test public void testAllFilesPresentInSpecializedGenerics() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/invokedynamic/sam/specializedGenerics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/invokedynamic/serializable") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Serializable extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Serializable { + @Test public void testAllFilesPresentInSerializable() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/invokedynamic/serializable"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/involvesIrInterpreter") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class InvolvesIrInterpreter extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class InvolvesIrInterpreter { + @Test public void testAllFilesPresentInInvolvesIrInterpreter() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/involvesIrInterpreter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt55912.kt") public void testKt55912() throws Exception { runTest("compiler/testData/codegen/box/involvesIrInterpreter/kt55912.kt"); } + @Test @TestMetadata("kt56215.kt") public void testKt56215() throws Exception { runTest("compiler/testData/codegen/box/involvesIrInterpreter/kt56215.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/involvesIrInterpreter/intrinsicConst") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class IntrinsicConst extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class IntrinsicConst { + @Test public void testAllFilesPresentInIntrinsicConst() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/involvesIrInterpreter/intrinsicConst"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/involvesIrInterpreter/serialization") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Serialization extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Serialization { + @Test public void testAllFilesPresentInSerialization() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/involvesIrInterpreter/serialization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/ir") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Ir extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Ir { + @Test public void testAllFilesPresentInIr() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("anonymousClassLeak.kt") public void testAnonymousClassLeak() throws Exception { runTest("compiler/testData/codegen/box/ir/anonymousClassLeak.kt"); } + @Test @TestMetadata("anonymousObjectInForLoopIteratorAndBody.kt") public void testAnonymousObjectInForLoopIteratorAndBody() throws Exception { runTest("compiler/testData/codegen/box/ir/anonymousObjectInForLoopIteratorAndBody.kt"); } + @Test @TestMetadata("anonymousObjectInGenericFun.kt") public void testAnonymousObjectInGenericFun() throws Exception { runTest("compiler/testData/codegen/box/ir/anonymousObjectInGenericFun.kt"); } + @Test @TestMetadata("anonymousObjectInsideElvis.kt") public void testAnonymousObjectInsideElvis() throws Exception { runTest("compiler/testData/codegen/box/ir/anonymousObjectInsideElvis.kt"); } + @Test @TestMetadata("classInitializers.kt") public void testClassInitializers() throws Exception { runTest("compiler/testData/codegen/box/ir/classInitializers.kt"); } + @Test @TestMetadata("enumClass.kt") public void testEnumClass() throws Exception { runTest("compiler/testData/codegen/box/ir/enumClass.kt"); } + @Test @TestMetadata("enumClass2.kt") public void testEnumClass2() throws Exception { runTest("compiler/testData/codegen/box/ir/enumClass2.kt"); } + @Test @TestMetadata("enumClass3.kt") public void testEnumClass3() throws Exception { runTest("compiler/testData/codegen/box/ir/enumClass3.kt"); } + @Test @TestMetadata("fileClassInitializers.kt") public void testFileClassInitializers() throws Exception { runTest("compiler/testData/codegen/box/ir/fileClassInitializers.kt"); } + @Test @TestMetadata("genericCompanion.kt") public void testGenericCompanion() throws Exception { runTest("compiler/testData/codegen/box/ir/genericCompanion.kt"); } + @Test @TestMetadata("hashCodeOnGenericSubstitutedWithPrimitive.kt") public void testHashCodeOnGenericSubstitutedWithPrimitive() throws Exception { runTest("compiler/testData/codegen/box/ir/hashCodeOnGenericSubstitutedWithPrimitive.kt"); } + @Test @TestMetadata("kt25405.kt") public void testKt25405() throws Exception { runTest("compiler/testData/codegen/box/ir/kt25405.kt"); } + @Test @TestMetadata("kt40083.kt") public void testKt40083() throws Exception { runTest("compiler/testData/codegen/box/ir/kt40083.kt"); } + @Test @TestMetadata("kt41765.kt") public void testKt41765() throws Exception { runTest("compiler/testData/codegen/box/ir/kt41765.kt"); } + @Test @TestMetadata("kt52677.kt") public void testKt52677() throws Exception { runTest("compiler/testData/codegen/box/ir/kt52677.kt"); } + @Test @TestMetadata("kt55318.kt") public void testKt55318() throws Exception { runTest("compiler/testData/codegen/box/ir/kt55318.kt"); } + @Test @TestMetadata("lambdaWithLoop.kt") public void testLambdaWithLoop() throws Exception { runTest("compiler/testData/codegen/box/ir/lambdaWithLoop.kt"); } + @Test @TestMetadata("objectClass.kt") public void testObjectClass() throws Exception { runTest("compiler/testData/codegen/box/ir/objectClass.kt"); } + @Test @TestMetadata("recursiveGeneric.kt") public void testRecursiveGeneric() throws Exception { runTest("compiler/testData/codegen/box/ir/recursiveGeneric.kt"); } + @Test @TestMetadata("recursiveGeneric2.kt") public void testRecursiveGeneric2() throws Exception { runTest("compiler/testData/codegen/box/ir/recursiveGeneric2.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/ir/simple.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/ir/closureConversion") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ClosureConversion extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ClosureConversion { + @Test public void testAllFilesPresentInClosureConversion() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/closureConversion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("closureConversion1.kt") public void testClosureConversion1() throws Exception { runTest("compiler/testData/codegen/box/ir/closureConversion/closureConversion1.kt"); } + @Test @TestMetadata("closureConversion2.kt") public void testClosureConversion2() throws Exception { runTest("compiler/testData/codegen/box/ir/closureConversion/closureConversion2.kt"); } + @Test @TestMetadata("closureConversion3.kt") public void testClosureConversion3() throws Exception { runTest("compiler/testData/codegen/box/ir/closureConversion/closureConversion3.kt"); } + @Test @TestMetadata("closureConversion4.kt") public void testClosureConversion4() throws Exception { runTest("compiler/testData/codegen/box/ir/closureConversion/closureConversion4.kt"); } + @Test @TestMetadata("innerClass1.kt") public void testInnerClass1() throws Exception { runTest("compiler/testData/codegen/box/ir/closureConversion/innerClass1.kt"); } + @Test @TestMetadata("innerClass2.kt") public void testInnerClass2() throws Exception { runTest("compiler/testData/codegen/box/ir/closureConversion/innerClass2.kt"); } + @Test @TestMetadata("mutable1.kt") public void testMutable1() throws Exception { runTest("compiler/testData/codegen/box/ir/closureConversion/mutable1.kt"); } + @Test @TestMetadata("mutablePrimitives.kt") public void testMutablePrimitives() throws Exception { runTest("compiler/testData/codegen/box/ir/closureConversion/mutablePrimitives.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ir/primitiveNumberComparisons") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class PrimitiveNumberComparisons extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class PrimitiveNumberComparisons { + @Test public void testAllFilesPresentInPrimitiveNumberComparisons() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/primitiveNumberComparisons"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("comparableToDouble.kt") public void testComparableToDouble() throws Exception { runTest("compiler/testData/codegen/box/ir/primitiveNumberComparisons/comparableToDouble.kt"); } + @Test @TestMetadata("doubleEqeq.kt") public void testDoubleEqeq() throws Exception { runTest("compiler/testData/codegen/box/ir/primitiveNumberComparisons/doubleEqeq.kt"); } + @Test @TestMetadata("floatEqeq.kt") public void testFloatEqeq() throws Exception { runTest("compiler/testData/codegen/box/ir/primitiveNumberComparisons/floatEqeq.kt"); } + @Test @TestMetadata("mixedNumberTypes.kt") public void testMixedNumberTypes() throws Exception { runTest("compiler/testData/codegen/box/ir/primitiveNumberComparisons/mixedNumberTypes.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ir/privateSignatures") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class PrivateSignatures extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class PrivateSignatures { + @Test public void testAllFilesPresentInPrivateSignatures() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/privateSignatures"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("enumEntryArguments.kt") public void testEnumEntryArguments() throws Exception { runTest("compiler/testData/codegen/box/ir/privateSignatures/enumEntryArguments.kt"); } + @Test @TestMetadata("privateLeakThroughInline.kt") public void testPrivateLeakThroughInline() throws Exception { runTest("compiler/testData/codegen/box/ir/privateSignatures/privateLeakThroughInline.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ir/serializationRegressions") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SerializationRegressions extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class SerializationRegressions { + @Test public void testAllFilesPresentInSerializationRegressions() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/serializationRegressions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("anonFakeOverride.kt") public void testAnonFakeOverride() throws Exception { runTest("compiler/testData/codegen/box/ir/serializationRegressions/anonFakeOverride.kt"); } + @Test @TestMetadata("deepGenericDelegatedProperty.kt") public void testDeepGenericDelegatedProperty() throws Exception { runTest("compiler/testData/codegen/box/ir/serializationRegressions/deepGenericDelegatedProperty.kt"); } + @Test @TestMetadata("dispatchReceiverValue.kt") public void testDispatchReceiverValue() throws Exception { runTest("compiler/testData/codegen/box/ir/serializationRegressions/dispatchReceiverValue.kt"); } + @Test @TestMetadata("genericProperty.kt") public void testGenericProperty() throws Exception { runTest("compiler/testData/codegen/box/ir/serializationRegressions/genericProperty.kt"); } + @Test @TestMetadata("innerClassInEnumEntryClass.kt") public void testInnerClassInEnumEntryClass() throws Exception { runTest("compiler/testData/codegen/box/ir/serializationRegressions/innerClassInEnumEntryClass.kt"); } + @Test @TestMetadata("signatureClash.kt") public void testSignatureClash() throws Exception { runTest("compiler/testData/codegen/box/ir/serializationRegressions/signatureClash.kt"); } + @Test @TestMetadata("transitiveClash.kt") public void testTransitiveClash() throws Exception { runTest("compiler/testData/codegen/box/ir/serializationRegressions/transitiveClash.kt"); } + @Test @TestMetadata("useImportedMember.kt") public void testUseImportedMember() throws Exception { runTest("compiler/testData/codegen/box/ir/serializationRegressions/useImportedMember.kt"); } + @Test @TestMetadata("varAsFunctionCall.kt") public void testVarAsFunctionCall() throws Exception { runTest("compiler/testData/codegen/box/ir/serializationRegressions/varAsFunctionCall.kt"); @@ -18984,666 +21428,581 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/javaFieldAndKotlinProperty") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class JavaFieldAndKotlinProperty extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class JavaFieldAndKotlinProperty { + @Test public void testAllFilesPresentInJavaFieldAndKotlinProperty() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaFieldAndKotlinProperty"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/javaInterop") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class JavaInterop extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class JavaInterop { + @Test public void testAllFilesPresentInJavaInterop() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/javaInterop/foreignAnnotationsTests") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ForeignAnnotationsTests extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ForeignAnnotationsTests { + @Test public void testAllFilesPresentInForeignAnnotationsTests() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/foreignAnnotationsTests"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/javaInterop/foreignAnnotationsTests/tests") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Tests extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Tests { + @Test public void testAllFilesPresentInTests() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/foreignAnnotationsTests/tests"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/javaInterop/generics") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Generics extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Generics { + @Test public void testAllFilesPresentInGenerics() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/generics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/javaInterop/notNullAssertions") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NotNullAssertions extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NotNullAssertions { + @Test public void testAllFilesPresentInNotNullAssertions() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("mapPut.kt") public void testMapPut() throws Exception { runTest("compiler/testData/codegen/box/javaInterop/notNullAssertions/mapPut.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/javaInterop/notNullAssertions/enhancedNullability") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class EnhancedNullability extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class EnhancedNullability { + @Test public void testAllFilesPresentInEnhancedNullability() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/enhancedNullability"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/javaInterop/notNullAssertions/expressionAssertionMessages") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ExpressionAssertionMessages extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ExpressionAssertionMessages { + @Test public void testAllFilesPresentInExpressionAssertionMessages() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/expressionAssertionMessages"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/javaInterop/notNullAssertions/nullCheckOnLambdaReturnValue") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NullCheckOnLambdaReturnValue extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NullCheckOnLambdaReturnValue { + @Test public void testAllFilesPresentInNullCheckOnLambdaReturnValue() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/nullCheckOnLambdaReturnValue"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/javaInterop/objectMethods") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ObjectMethods extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ObjectMethods { + @Test public void testAllFilesPresentInObjectMethods() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/objectMethods"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/javaVisibility") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class JavaVisibility extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class JavaVisibility { + @Test public void testAllFilesPresentInJavaVisibility() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaVisibility"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/javaVisibility/package") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Package extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Package { + @Test public void testAllFilesPresentInPackage() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaVisibility/package"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/javaVisibility/protectedAndPackage") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ProtectedAndPackage extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ProtectedAndPackage { + @Test public void testAllFilesPresentInProtectedAndPackage() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaVisibility/protectedAndPackage"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/javaVisibility/protectedStatic") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ProtectedStatic extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ProtectedStatic { + @Test public void testAllFilesPresentInProtectedStatic() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaVisibility/protectedStatic"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/jdk") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Jdk extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Jdk { + @Test public void testAllFilesPresentInJdk() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jdk"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("arrayList.kt") public void testArrayList() throws Exception { runTest("compiler/testData/codegen/box/jdk/arrayList.kt"); } + @Test @TestMetadata("hashMap.kt") public void testHashMap() throws Exception { runTest("compiler/testData/codegen/box/jdk/hashMap.kt"); } + @Test @TestMetadata("iteratingOverHashMap.kt") public void testIteratingOverHashMap() throws Exception { runTest("compiler/testData/codegen/box/jdk/iteratingOverHashMap.kt"); } + @Test @TestMetadata("kt1397.kt") public void testKt1397() throws Exception { runTest("compiler/testData/codegen/box/jdk/kt1397.kt"); } + @Test @TestMetadata("noStringToCharArray.kt") public void testNoStringToCharArray() throws Exception { runTest("compiler/testData/codegen/box/jdk/noStringToCharArray.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/js") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Js extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Js { + @Test public void testAllFilesPresentInJs() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/js"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/jvm8") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Jvm8 extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Jvm8 { + @Test public void testAllFilesPresentInJvm8() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/jvm8/defaults") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Defaults extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Defaults { + @Test public void testAllFilesPresentInDefaults() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/allCompatibility") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class AllCompatibility extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class AllCompatibility { + @Test public void testAllFilesPresentInAllCompatibility() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/delegationBy") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DelegationBy extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DelegationBy { + @Test public void testAllFilesPresentInDelegationBy() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/delegationBy") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DelegationBy extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DelegationBy { + @Test public void testAllFilesPresentInDelegationBy() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/delegationBy"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NoDefaultImpls extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NoDefaultImpls { + @Test public void testAllFilesPresentInNoDefaultImpls() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/delegationBy") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DelegationBy extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DelegationBy { + @Test public void testAllFilesPresentInDelegationBy() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/delegationBy"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/specialization") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Specialization extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Specialization { + @Test public void testAllFilesPresentInSpecialization() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/specialization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/withCompatibility") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class WithCompatibility extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class WithCompatibility { + @Test public void testAllFilesPresentInWithCompatibility() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/withCompatibility"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NonDefaultInheritance extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NonDefaultInheritance { + @Test public void testAllFilesPresentInNonDefaultInheritance() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/reflection") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Reflection extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Reflection { + @Test public void testAllFilesPresentInReflection() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/reflection"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/jvm8/interfaceFlag") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class InterfaceFlag extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class InterfaceFlag { + @Test public void testAllFilesPresentInInterfaceFlag() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/interfaceFlag"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/jvm8/javaDefaults") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class JavaDefaults extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class JavaDefaults { + @Test public void testAllFilesPresentInJavaDefaults() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/javaDefaults"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/jvmField") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class JvmField extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class JvmField { + @Test public void testAllFilesPresentInJvmField() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmField"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/jvmName") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class JvmName extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class JvmName { + @Test public void testAllFilesPresentInJvmName() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/jvmName/fileFacades") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class FileFacades extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class FileFacades { + @Test public void testAllFilesPresentInFileFacades() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName/fileFacades"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/jvmOverloads") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class JvmOverloads extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class JvmOverloads { + @Test public void testAllFilesPresentInJvmOverloads() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmOverloads"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/jvmPackageName") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class JvmPackageName extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class JvmPackageName { + @Test public void testAllFilesPresentInJvmPackageName() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmPackageName"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/jvmStatic") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class JvmStatic extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class JvmStatic { + @Test public void testAllFilesPresentInJvmStatic() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmStatic"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/jvmStatic/protectedInSuperClass") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ProtectedInSuperClass extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ProtectedInSuperClass { + @Test public void testAllFilesPresentInProtectedInSuperClass() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmStatic/protectedInSuperClass"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/labels") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Labels extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Labels { + @Test public void testAllFilesPresentInLabels() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/labels"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("controlLabelClashesWithFuncitonName.kt") public void testControlLabelClashesWithFuncitonName() throws Exception { runTest("compiler/testData/codegen/box/labels/controlLabelClashesWithFuncitonName.kt"); } + @Test @TestMetadata("infixCallLabelling.kt") public void testInfixCallLabelling() throws Exception { runTest("compiler/testData/codegen/box/labels/infixCallLabelling.kt"); } + @Test @TestMetadata("labeledDeclarations.kt") public void testLabeledDeclarations() throws Exception { runTest("compiler/testData/codegen/box/labels/labeledDeclarations.kt"); } + @Test @TestMetadata("propertyAccessor.kt") public void testPropertyAccessor() throws Exception { runTest("compiler/testData/codegen/box/labels/propertyAccessor.kt"); } + @Test @TestMetadata("propertyAccessorFunctionLiteral.kt") public void testPropertyAccessorFunctionLiteral() throws Exception { runTest("compiler/testData/codegen/box/labels/propertyAccessorFunctionLiteral.kt"); } + @Test @TestMetadata("propertyAccessorInnerExtensionFun.kt") public void testPropertyAccessorInnerExtensionFun() throws Exception { runTest("compiler/testData/codegen/box/labels/propertyAccessorInnerExtensionFun.kt"); } + @Test @TestMetadata("propertyAccessorObject.kt") public void testPropertyAccessorObject() throws Exception { runTest("compiler/testData/codegen/box/labels/propertyAccessorObject.kt"); } + @Test @TestMetadata("propertyInClassAccessor.kt") public void testPropertyInClassAccessor() throws Exception { runTest("compiler/testData/codegen/box/labels/propertyInClassAccessor.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/lazyCodegen") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class LazyCodegen extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class LazyCodegen { + @Test public void testAllFilesPresentInLazyCodegen() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("exceptionInFieldInitializer.kt") public void testExceptionInFieldInitializer() throws Exception { runTest("compiler/testData/codegen/box/lazyCodegen/exceptionInFieldInitializer.kt"); } + @Test @TestMetadata("ifElse.kt") public void testIfElse() throws Exception { runTest("compiler/testData/codegen/box/lazyCodegen/ifElse.kt"); } + @Test @TestMetadata("increment.kt") public void testIncrement() throws Exception { runTest("compiler/testData/codegen/box/lazyCodegen/increment.kt"); } + @Test @TestMetadata("safeAssign.kt") public void testSafeAssign() throws Exception { runTest("compiler/testData/codegen/box/lazyCodegen/safeAssign.kt"); } + @Test @TestMetadata("safeAssignComplex.kt") public void testSafeAssignComplex() throws Exception { runTest("compiler/testData/codegen/box/lazyCodegen/safeAssignComplex.kt"); } + @Test @TestMetadata("safeCallAndArray.kt") public void testSafeCallAndArray() throws Exception { runTest("compiler/testData/codegen/box/lazyCodegen/safeCallAndArray.kt"); } + @Test @TestMetadata("toString.kt") public void testToString() throws Exception { runTest("compiler/testData/codegen/box/lazyCodegen/toString.kt"); } + @Test @TestMetadata("tryCatchExpression.kt") public void testTryCatchExpression() throws Exception { runTest("compiler/testData/codegen/box/lazyCodegen/tryCatchExpression.kt"); } + @Test @TestMetadata("when.kt") public void testWhen() throws Exception { runTest("compiler/testData/codegen/box/lazyCodegen/when.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/lazyCodegen/optimizations") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Optimizations extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Optimizations { + @Test public void testAllFilesPresentInOptimizations() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen/optimizations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("negateConstantCompare.kt") public void testNegateConstantCompare() throws Exception { runTest("compiler/testData/codegen/box/lazyCodegen/optimizations/negateConstantCompare.kt"); } + @Test @TestMetadata("negateFalse.kt") public void testNegateFalse() throws Exception { runTest("compiler/testData/codegen/box/lazyCodegen/optimizations/negateFalse.kt"); } + @Test @TestMetadata("negateFalseVar.kt") public void testNegateFalseVar() throws Exception { runTest("compiler/testData/codegen/box/lazyCodegen/optimizations/negateFalseVar.kt"); } + @Test @TestMetadata("negateFalseVarChain.kt") public void testNegateFalseVarChain() throws Exception { runTest("compiler/testData/codegen/box/lazyCodegen/optimizations/negateFalseVarChain.kt"); } + @Test @TestMetadata("negateObjectComp.kt") public void testNegateObjectComp() throws Exception { runTest("compiler/testData/codegen/box/lazyCodegen/optimizations/negateObjectComp.kt"); } + @Test @TestMetadata("negateObjectComp2.kt") public void testNegateObjectComp2() throws Exception { runTest("compiler/testData/codegen/box/lazyCodegen/optimizations/negateObjectComp2.kt"); } + @Test @TestMetadata("negateTrue.kt") public void testNegateTrue() throws Exception { runTest("compiler/testData/codegen/box/lazyCodegen/optimizations/negateTrue.kt"); } + @Test @TestMetadata("negateTrueVar.kt") public void testNegateTrueVar() throws Exception { runTest("compiler/testData/codegen/box/lazyCodegen/optimizations/negateTrueVar.kt"); } + @Test @TestMetadata("noOptimization.kt") public void testNoOptimization() throws Exception { runTest("compiler/testData/codegen/box/lazyCodegen/optimizations/noOptimization.kt"); @@ -19651,441 +22010,496 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/localClasses") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class LocalClasses extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class LocalClasses { + @Test public void testAllFilesPresentInLocalClasses() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/localClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("anonymousObjectInExtension.kt") public void testAnonymousObjectInExtension() throws Exception { runTest("compiler/testData/codegen/box/localClasses/anonymousObjectInExtension.kt"); } + @Test @TestMetadata("anonymousObjectInInitializer.kt") public void testAnonymousObjectInInitializer() throws Exception { runTest("compiler/testData/codegen/box/localClasses/anonymousObjectInInitializer.kt"); } + @Test @TestMetadata("anonymousObjectInParameterInitializer.kt") public void testAnonymousObjectInParameterInitializer() throws Exception { runTest("compiler/testData/codegen/box/localClasses/anonymousObjectInParameterInitializer.kt"); } + @Test @TestMetadata("capturingInDefaultConstructorParameter.kt") public void testCapturingInDefaultConstructorParameter() throws Exception { runTest("compiler/testData/codegen/box/localClasses/capturingInDefaultConstructorParameter.kt"); } + @Test @TestMetadata("closureOfInnerLocalClass.kt") public void testClosureOfInnerLocalClass() throws Exception { runTest("compiler/testData/codegen/box/localClasses/closureOfInnerLocalClass.kt"); } + @Test @TestMetadata("closureOfLambdaInLocalClass.kt") public void testClosureOfLambdaInLocalClass() throws Exception { runTest("compiler/testData/codegen/box/localClasses/closureOfLambdaInLocalClass.kt"); } + @Test @TestMetadata("closureWithSelfInstantiation.kt") public void testClosureWithSelfInstantiation() throws Exception { runTest("compiler/testData/codegen/box/localClasses/closureWithSelfInstantiation.kt"); } + @Test @TestMetadata("defaultParameterInConstructor.kt") public void testDefaultParameterInConstructor() throws Exception { runTest("compiler/testData/codegen/box/localClasses/defaultParameterInConstructor.kt"); } + @Test @TestMetadata("inExtensionFunction.kt") public void testInExtensionFunction() throws Exception { runTest("compiler/testData/codegen/box/localClasses/inExtensionFunction.kt"); } + @Test @TestMetadata("inExtensionProperty.kt") public void testInExtensionProperty() throws Exception { runTest("compiler/testData/codegen/box/localClasses/inExtensionProperty.kt"); } + @Test @TestMetadata("inLocalExtensionFunction.kt") public void testInLocalExtensionFunction() throws Exception { runTest("compiler/testData/codegen/box/localClasses/inLocalExtensionFunction.kt"); } + @Test @TestMetadata("inLocalExtensionProperty.kt") public void testInLocalExtensionProperty() throws Exception { runTest("compiler/testData/codegen/box/localClasses/inLocalExtensionProperty.kt"); } + @Test @TestMetadata("innerClassInLocalClass.kt") public void testInnerClassInLocalClass() throws Exception { runTest("compiler/testData/codegen/box/localClasses/innerClassInLocalClass.kt"); } + @Test @TestMetadata("innerOfLocalCaptureExtensionReceiver.kt") public void testInnerOfLocalCaptureExtensionReceiver() throws Exception { runTest("compiler/testData/codegen/box/localClasses/innerOfLocalCaptureExtensionReceiver.kt"); } + @Test @TestMetadata("kt10835.kt") public void testKt10835() throws Exception { runTest("compiler/testData/codegen/box/localClasses/kt10835.kt"); } + @Test @TestMetadata("kt10835a.kt") public void testKt10835a() throws Exception { runTest("compiler/testData/codegen/box/localClasses/kt10835a.kt"); } + @Test @TestMetadata("kt2700.kt") public void testKt2700() throws Exception { runTest("compiler/testData/codegen/box/localClasses/kt2700.kt"); } + @Test @TestMetadata("kt2873.kt") public void testKt2873() throws Exception { runTest("compiler/testData/codegen/box/localClasses/kt2873.kt"); } + @Test @TestMetadata("kt3210.kt") public void testKt3210() throws Exception { runTest("compiler/testData/codegen/box/localClasses/kt3210.kt"); } + @Test @TestMetadata("kt3389.kt") public void testKt3389() throws Exception { runTest("compiler/testData/codegen/box/localClasses/kt3389.kt"); } + @Test @TestMetadata("kt3584.kt") public void testKt3584() throws Exception { runTest("compiler/testData/codegen/box/localClasses/kt3584.kt"); } + @Test @TestMetadata("kt4174.kt") public void testKt4174() throws Exception { runTest("compiler/testData/codegen/box/localClasses/kt4174.kt"); } + @Test @TestMetadata("kt45383.kt") public void testKt45383() throws Exception { runTest("compiler/testData/codegen/box/localClasses/kt45383.kt"); } + @Test @TestMetadata("localClass.kt") public void testLocalClass() throws Exception { runTest("compiler/testData/codegen/box/localClasses/localClass.kt"); } + @Test @TestMetadata("localClassCaptureExtensionReceiver.kt") public void testLocalClassCaptureExtensionReceiver() throws Exception { runTest("compiler/testData/codegen/box/localClasses/localClassCaptureExtensionReceiver.kt"); } + @Test @TestMetadata("localClassInInitializer.kt") public void testLocalClassInInitializer() throws Exception { runTest("compiler/testData/codegen/box/localClasses/localClassInInitializer.kt"); } + @Test @TestMetadata("localClassInParameterInitializer.kt") public void testLocalClassInParameterInitializer() throws Exception { runTest("compiler/testData/codegen/box/localClasses/localClassInParameterInitializer.kt"); } + @Test @TestMetadata("localClassUsedBeforeDeclaration.kt") public void testLocalClassUsedBeforeDeclaration() throws Exception { runTest("compiler/testData/codegen/box/localClasses/localClassUsedBeforeDeclaration.kt"); } + @Test @TestMetadata("localDataClass.kt") public void testLocalDataClass() throws Exception { runTest("compiler/testData/codegen/box/localClasses/localDataClass.kt"); } + @Test @TestMetadata("localExtendsInnerAndReferencesOuterMember.kt") public void testLocalExtendsInnerAndReferencesOuterMember() throws Exception { runTest("compiler/testData/codegen/box/localClasses/localExtendsInnerAndReferencesOuterMember.kt"); } + @Test @TestMetadata("localGenericWithTypeParameters.kt") public void testLocalGenericWithTypeParameters() throws Exception { runTest("compiler/testData/codegen/box/localClasses/localGenericWithTypeParameters.kt"); } + @Test @TestMetadata("nameWithWhitespace.kt") public void testNameWithWhitespace() throws Exception { runTest("compiler/testData/codegen/box/localClasses/nameWithWhitespace.kt"); } + @Test @TestMetadata("noclosure.kt") public void testNoclosure() throws Exception { runTest("compiler/testData/codegen/box/localClasses/noclosure.kt"); } + @Test @TestMetadata("object.kt") public void testObject() throws Exception { runTest("compiler/testData/codegen/box/localClasses/object.kt"); } + @Test @TestMetadata("ownClosureOfInnerLocalClass.kt") public void testOwnClosureOfInnerLocalClass() throws Exception { runTest("compiler/testData/codegen/box/localClasses/ownClosureOfInnerLocalClass.kt"); } + @Test @TestMetadata("recaptureVarCapturedInLocalClass1.kt") public void testRecaptureVarCapturedInLocalClass1() throws Exception { runTest("compiler/testData/codegen/box/localClasses/recaptureVarCapturedInLocalClass1.kt"); } + @Test @TestMetadata("recaptureVarCapturedInLocalClass2.kt") public void testRecaptureVarCapturedInLocalClass2() throws Exception { runTest("compiler/testData/codegen/box/localClasses/recaptureVarCapturedInLocalClass2.kt"); } + @Test @TestMetadata("recaptureVarCapturedInLocalClass3.kt") public void testRecaptureVarCapturedInLocalClass3() throws Exception { runTest("compiler/testData/codegen/box/localClasses/recaptureVarCapturedInLocalClass3.kt"); } + @Test @TestMetadata("subclassingExtensionReceiverClass.kt") public void testSubclassingExtensionReceiverClass() throws Exception { runTest("compiler/testData/codegen/box/localClasses/subclassingExtensionReceiverClass.kt"); } + @Test @TestMetadata("withclosure.kt") public void testWithclosure() throws Exception { runTest("compiler/testData/codegen/box/localClasses/withclosure.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/mangling") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Mangling extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Mangling { + @Test public void testAllFilesPresentInMangling() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mangling"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("internal.kt") public void testInternal() throws Exception { runTest("compiler/testData/codegen/box/mangling/internal.kt"); } + @Test @TestMetadata("internalOverride.kt") public void testInternalOverride() throws Exception { runTest("compiler/testData/codegen/box/mangling/internalOverride.kt"); } + @Test @TestMetadata("internalOverrideSuperCall.kt") public void testInternalOverrideSuperCall() throws Exception { runTest("compiler/testData/codegen/box/mangling/internalOverrideSuperCall.kt"); } + @Test @TestMetadata("parentheses.kt") public void testParentheses() throws Exception { runTest("compiler/testData/codegen/box/mangling/parentheses.kt"); } + @Test @TestMetadata("publicOverride.kt") public void testPublicOverride() throws Exception { runTest("compiler/testData/codegen/box/mangling/publicOverride.kt"); } + @Test @TestMetadata("publicOverrideSuperCall.kt") public void testPublicOverrideSuperCall() throws Exception { runTest("compiler/testData/codegen/box/mangling/publicOverrideSuperCall.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/mixedNamedPosition") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class MixedNamedPosition extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class MixedNamedPosition { + @Test public void testAllFilesPresentInMixedNamedPosition() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mixedNamedPosition"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("defaults.kt") public void testDefaults() throws Exception { runTest("compiler/testData/codegen/box/mixedNamedPosition/defaults.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/mixedNamedPosition/simple.kt"); } + @Test @TestMetadata("varargs.kt") public void testVarargs() throws Exception { runTest("compiler/testData/codegen/box/mixedNamedPosition/varargs.kt"); } + @Test @TestMetadata("varargsEvaluationOrder.kt") public void testVarargsEvaluationOrder() throws Exception { runTest("compiler/testData/codegen/box/mixedNamedPosition/varargsEvaluationOrder.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/multiDecl") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class MultiDecl extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class MultiDecl { + @Test public void testAllFilesPresentInMultiDecl() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("ComplexInitializer.kt") public void testComplexInitializer() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/ComplexInitializer.kt"); } + @Test @TestMetadata("component.kt") public void testComponent() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/component.kt"); } + @Test @TestMetadata("kt9828_hashMap.kt") public void testKt9828_hashMap() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/kt9828_hashMap.kt"); } + @Test @TestMetadata("returnInElvis.kt") public void testReturnInElvis() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/returnInElvis.kt"); } + @Test @TestMetadata("SimpleVals.kt") public void testSimpleVals() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/SimpleVals.kt"); } + @Test @TestMetadata("SimpleValsExtensions.kt") public void testSimpleValsExtensions() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/SimpleValsExtensions.kt"); } + @Test @TestMetadata("SimpleVarsExtensions.kt") public void testSimpleVarsExtensions() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/SimpleVarsExtensions.kt"); } + @Test @TestMetadata("UnderscoreNames.kt") public void testUnderscoreNames() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/UnderscoreNames.kt"); } + @Test @TestMetadata("ValCapturedInFunctionLiteral.kt") public void testValCapturedInFunctionLiteral() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/ValCapturedInFunctionLiteral.kt"); } + @Test @TestMetadata("ValCapturedInLocalFunction.kt") public void testValCapturedInLocalFunction() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/ValCapturedInLocalFunction.kt"); } + @Test @TestMetadata("ValCapturedInObjectLiteral.kt") public void testValCapturedInObjectLiteral() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/ValCapturedInObjectLiteral.kt"); } + @Test @TestMetadata("VarCapturedInFunctionLiteral.kt") public void testVarCapturedInFunctionLiteral() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/VarCapturedInFunctionLiteral.kt"); } + @Test @TestMetadata("VarCapturedInLocalFunction.kt") public void testVarCapturedInLocalFunction() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/VarCapturedInLocalFunction.kt"); } + @Test @TestMetadata("VarCapturedInObjectLiteral.kt") public void testVarCapturedInObjectLiteral() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/VarCapturedInObjectLiteral.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/multiDecl/forIterator") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ForIterator extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ForIterator { + @Test public void testAllFilesPresentInForIterator() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("MultiDeclFor.kt") public void testMultiDeclFor() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forIterator/MultiDeclFor.kt"); } + @Test @TestMetadata("MultiDeclForComponentExtensions.kt") public void testMultiDeclForComponentExtensions() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forIterator/MultiDeclForComponentExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensions.kt") public void testMultiDeclForComponentMemberExtensions() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forIterator/MultiDeclForComponentMemberExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forIterator/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); } + @Test @TestMetadata("MultiDeclForValCaptured.kt") public void testMultiDeclForValCaptured() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forIterator/MultiDeclForValCaptured.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/multiDecl/forIterator/longIterator") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class LongIterator extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class LongIterator { + @Test public void testAllFilesPresentInLongIterator() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator/longIterator"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("MultiDeclForComponentExtensions.kt") public void testMultiDeclForComponentExtensions() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forIterator/longIterator/MultiDeclForComponentExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentExtensionsValCaptured.kt") public void testMultiDeclForComponentExtensionsValCaptured() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forIterator/longIterator/MultiDeclForComponentExtensionsValCaptured.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensions.kt") public void testMultiDeclForComponentMemberExtensions() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forIterator/longIterator/MultiDeclForComponentMemberExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forIterator/longIterator/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); @@ -20093,150 +22507,158 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/multiDecl/forRange") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ForRange extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ForRange { + @Test public void testAllFilesPresentInForRange() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("MultiDeclFor.kt") public void testMultiDeclFor() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/MultiDeclFor.kt"); } + @Test @TestMetadata("MultiDeclForComponentExtensions.kt") public void testMultiDeclForComponentExtensions() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/MultiDeclForComponentExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensions.kt") public void testMultiDeclForComponentMemberExtensions() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/MultiDeclForComponentMemberExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); } + @Test @TestMetadata("MultiDeclForValCaptured.kt") public void testMultiDeclForValCaptured() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/MultiDeclForValCaptured.kt"); } + @Test @TestMetadata("UnderscoreNames.kt") public void testUnderscoreNames() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/UnderscoreNames.kt"); } + @Test @TestMetadata("UnderscoreNamesDontCallComponent.kt") public void testUnderscoreNamesDontCallComponent() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/UnderscoreNamesDontCallComponent.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ExplicitRangeTo extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ExplicitRangeTo { + @Test public void testAllFilesPresentInExplicitRangeTo() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("MultiDeclFor.kt") public void testMultiDeclFor() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/MultiDeclFor.kt"); } + @Test @TestMetadata("MultiDeclForComponentExtensions.kt") public void testMultiDeclForComponentExtensions() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/MultiDeclForComponentExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensions.kt") public void testMultiDeclForComponentMemberExtensions() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/MultiDeclForComponentMemberExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); } + @Test @TestMetadata("MultiDeclForValCaptured.kt") public void testMultiDeclForValCaptured() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/MultiDeclForValCaptured.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Int extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Int { + @Test public void testAllFilesPresentInInt() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("MultiDeclForComponentExtensions.kt") public void testMultiDeclForComponentExtensions() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int/MultiDeclForComponentExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentExtensionsValCaptured.kt") public void testMultiDeclForComponentExtensionsValCaptured() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int/MultiDeclForComponentExtensionsValCaptured.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensions.kt") public void testMultiDeclForComponentMemberExtensions() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int/MultiDeclForComponentMemberExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Long extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Long { + @Test public void testAllFilesPresentInLong() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("MultiDeclForComponentExtensions.kt") public void testMultiDeclForComponentExtensions() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long/MultiDeclForComponentExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentExtensionsValCaptured.kt") public void testMultiDeclForComponentExtensionsValCaptured() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long/MultiDeclForComponentExtensionsValCaptured.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensions.kt") public void testMultiDeclForComponentMemberExtensions() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long/MultiDeclForComponentMemberExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); @@ -20244,103 +22666,107 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ExplicitRangeToWithDot extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ExplicitRangeToWithDot { + @Test public void testAllFilesPresentInExplicitRangeToWithDot() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("MultiDeclFor.kt") public void testMultiDeclFor() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/MultiDeclFor.kt"); } + @Test @TestMetadata("MultiDeclForComponentExtensions.kt") public void testMultiDeclForComponentExtensions() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/MultiDeclForComponentExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensions.kt") public void testMultiDeclForComponentMemberExtensions() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/MultiDeclForComponentMemberExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); } + @Test @TestMetadata("MultiDeclForValCaptured.kt") public void testMultiDeclForValCaptured() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/MultiDeclForValCaptured.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Int extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Int { + @Test public void testAllFilesPresentInInt() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("MultiDeclForComponentExtensions.kt") public void testMultiDeclForComponentExtensions() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int/MultiDeclForComponentExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentExtensionsValCaptured.kt") public void testMultiDeclForComponentExtensionsValCaptured() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int/MultiDeclForComponentExtensionsValCaptured.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensions.kt") public void testMultiDeclForComponentMemberExtensions() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int/MultiDeclForComponentMemberExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Long extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Long { + @Test public void testAllFilesPresentInLong() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("MultiDeclForComponentExtensions.kt") public void testMultiDeclForComponentExtensions() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long/MultiDeclForComponentExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentExtensionsValCaptured.kt") public void testMultiDeclForComponentExtensionsValCaptured() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long/MultiDeclForComponentExtensionsValCaptured.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensions.kt") public void testMultiDeclForComponentMemberExtensions() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long/MultiDeclForComponentMemberExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); @@ -20348,66 +22774,68 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/multiDecl/forRange/int") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Int extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Int { + @Test public void testAllFilesPresentInInt() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/int"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("MultiDeclForComponentExtensions.kt") public void testMultiDeclForComponentExtensions() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/int/MultiDeclForComponentExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentExtensionsValCaptured.kt") public void testMultiDeclForComponentExtensionsValCaptured() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/int/MultiDeclForComponentExtensionsValCaptured.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensions.kt") public void testMultiDeclForComponentMemberExtensions() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/int/MultiDeclForComponentMemberExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/int/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/multiDecl/forRange/long") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Long extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Long { + @Test public void testAllFilesPresentInLong() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/long"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("MultiDeclForComponentExtensions.kt") public void testMultiDeclForComponentExtensions() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/long/MultiDeclForComponentExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentExtensionsValCaptured.kt") public void testMultiDeclForComponentExtensionsValCaptured() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/long/MultiDeclForComponentExtensionsValCaptured.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensions.kt") public void testMultiDeclForComponentMemberExtensions() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/long/MultiDeclForComponentMemberExtensions.kt"); } + @Test @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { runTest("compiler/testData/codegen/box/multiDecl/forRange/long/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); @@ -20416,591 +22844,648 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/multifileClasses") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class MultifileClasses extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class MultifileClasses { + @Test public void testAllFilesPresentInMultifileClasses() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/multifileClasses/optimized") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Optimized extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Optimized { + @Test public void testAllFilesPresentInOptimized() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses/optimized"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/multiplatform") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Multiplatform extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Multiplatform { + @Test public void testAllFilesPresentInMultiplatform() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("expectProperty.kt") public void testExpectProperty() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/expectProperty.kt"); } + @Test @TestMetadata("optionalExpectation.kt") public void testOptionalExpectation() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/optionalExpectation.kt"); } + @Test @TestMetadata("starImportOfExpectEnumWithActualTypeAlias.kt") public void testStarImportOfExpectEnumWithActualTypeAlias() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/starImportOfExpectEnumWithActualTypeAlias.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/multiplatform/defaultArguments") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DefaultArguments extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DefaultArguments { + @Test public void testAllFilesPresentInDefaultArguments() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/defaultArguments"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("bothInExpectAndActual.kt") public void testBothInExpectAndActual() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/bothInExpectAndActual.kt"); } + @Test @TestMetadata("bothInExpectAndActual2.kt") public void testBothInExpectAndActual2() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/bothInExpectAndActual2.kt"); } + @Test @TestMetadata("constructor.kt") public void testConstructor() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/constructor.kt"); } + @Test @TestMetadata("delegatedExpectedInterface.kt") public void testDelegatedExpectedInterface() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/delegatedExpectedInterface.kt"); } + @Test @TestMetadata("dispatchReceiverValue.kt") public void testDispatchReceiverValue() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/dispatchReceiverValue.kt"); } + @Test @TestMetadata("extensionReceiverValue.kt") public void testExtensionReceiverValue() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/extensionReceiverValue.kt"); } + @Test @TestMetadata("function.kt") public void testFunction() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/function.kt"); } + @Test @TestMetadata("functionFromOtherModule.kt") public void testFunctionFromOtherModule() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/functionFromOtherModule.kt"); } + @Test @TestMetadata("inheritedFromCommonClass.kt") public void testInheritedFromCommonClass() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/inheritedFromCommonClass.kt"); } + @Test @TestMetadata("inheritedFromExpectedClass.kt") public void testInheritedFromExpectedClass() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/inheritedFromExpectedClass.kt"); } + @Test @TestMetadata("inheritedFromExpectedInterface.kt") public void testInheritedFromExpectedInterface() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/inheritedFromExpectedInterface.kt"); } + @Test @TestMetadata("inheritedFromExpectedMethod.kt") public void testInheritedFromExpectedMethod() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/inheritedFromExpectedMethod.kt"); } + @Test @TestMetadata("inheritedInExpectedDeclarations.kt") public void testInheritedInExpectedDeclarations() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/inheritedInExpectedDeclarations.kt"); } + @Test @TestMetadata("inheritedViaAnotherInterfaceIndirectly.kt") public void testInheritedViaAnotherInterfaceIndirectly() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/inheritedViaAnotherInterfaceIndirectly.kt"); } + @Test @TestMetadata("inlineFunctionWithDefaultLambda.kt") public void testInlineFunctionWithDefaultLambda() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/inlineFunctionWithDefaultLambda.kt"); } + @Test @TestMetadata("kt23239.kt") public void testKt23239() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/kt23239.kt"); } + @Test @TestMetadata("kt23739.kt") public void testKt23739() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/kt23739.kt"); } + @Test @TestMetadata("nestedEnumEntryValue.kt") public void testNestedEnumEntryValue() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/nestedEnumEntryValue.kt"); } + @Test @TestMetadata("parametersInArgumentValues.kt") public void testParametersInArgumentValues() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/parametersInArgumentValues.kt"); } + @Test @TestMetadata("superCall.kt") public void testSuperCall() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/superCall.kt"); } + @Test @TestMetadata("suspend.kt") public void testSuspend() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/suspend.kt"); } + @Test @TestMetadata("typeAlias.kt") public void testTypeAlias() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/typeAlias.kt"); } + @Test @TestMetadata("typeAlias2.kt") public void testTypeAlias2() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/typeAlias2.kt"); } + @Test @TestMetadata("withTypeParameter.kt") public void testWithTypeParameter() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/withTypeParameter.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/multiplatform/exhaustiveness") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Exhaustiveness extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Exhaustiveness { + @Test public void testAllFilesPresentInExhaustiveness() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/exhaustiveness"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/multiplatform/hmpp") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Hmpp extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Hmpp { + @Test public void testAllFilesPresentInHmpp() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/hmpp"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/multiplatform/k2") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class K2 extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class K2 { + @Test public void testAllFilesPresentInK2() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/k2"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("anonymousObjectAndSpecificImplementationInDeserializedIr.kt") public void testAnonymousObjectAndSpecificImplementationInDeserializedIr() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/anonymousObjectAndSpecificImplementationInDeserializedIr.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/multiplatform/k2/annotations") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Annotations extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Annotations { + @Test public void testAllFilesPresentInAnnotations() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/k2/annotations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("optionalExpectation.kt") public void testOptionalExpectation() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/annotations/optionalExpectation.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/multiplatform/k2/basic") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Basic extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Basic { + @Test @TestMetadata("accessToLocalClassFromBackend.kt") public void testAccessToLocalClassFromBackend() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/accessToLocalClassFromBackend.kt"); } + @Test public void testAllFilesPresentInBasic() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/k2/basic"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("anyMethodInExpect.kt") public void testAnyMethodInExpect() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/anyMethodInExpect.kt"); } + @Test @TestMetadata("correctParentForTypeParameter.kt") public void testCorrectParentForTypeParameter() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/correctParentForTypeParameter.kt"); } + @Test @TestMetadata("enumEntryNameCall.kt") public void testEnumEntryNameCall() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/enumEntryNameCall.kt"); } + @Test @TestMetadata("expectActualCallableReference.kt") public void testExpectActualCallableReference() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualCallableReference.kt"); } + @Test @TestMetadata("expectActualDifferentExtensionReceiversOnOverloads.kt") public void testExpectActualDifferentExtensionReceiversOnOverloads() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualDifferentExtensionReceiversOnOverloads.kt"); } + @Test @TestMetadata("expectActualDifferentPackages.kt") public void testExpectActualDifferentPackages() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualDifferentPackages.kt"); } + @Test @TestMetadata("expectActualFakeOverrides.kt") public void testExpectActualFakeOverrides() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualFakeOverrides.kt"); } + @Test @TestMetadata("expectActualFakeOverrides2.kt") public void testExpectActualFakeOverrides2() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualFakeOverrides2.kt"); } + @Test @TestMetadata("expectActualFakeOverrides3.kt") public void testExpectActualFakeOverrides3() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualFakeOverrides3.kt"); } + @Test @TestMetadata("expectActualFakeOverridesWithTypeParameters.kt") public void testExpectActualFakeOverridesWithTypeParameters() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualFakeOverridesWithTypeParameters.kt"); } + @Test @TestMetadata("expectActualFakeOverridesWithTypeParameters2.kt") public void testExpectActualFakeOverridesWithTypeParameters2() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualFakeOverridesWithTypeParameters2.kt"); } + @Test @TestMetadata("expectActualIntersectionOverride.kt") public void testExpectActualIntersectionOverride() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualIntersectionOverride.kt"); } + @Test @TestMetadata("expectActualIntersectionOverride2.kt") public void testExpectActualIntersectionOverride2() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualIntersectionOverride2.kt"); } + @Test @TestMetadata("expectActualMultiCommon.kt") public void testExpectActualMultiCommon() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualMultiCommon.kt"); } + @Test @TestMetadata("expectActualNullabilityBasedOverloads.kt") public void testExpectActualNullabilityBasedOverloads() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualNullabilityBasedOverloads.kt"); } + @Test @TestMetadata("expectActualOverloads.kt") public void testExpectActualOverloads() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualOverloads.kt"); } + @Test @TestMetadata("expectActualSimple.kt") public void testExpectActualSimple() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualSimple.kt"); } + @Test @TestMetadata("expectActualTypeParameters.kt") public void testExpectActualTypeParameters() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualTypeParameters.kt"); } + @Test @TestMetadata("expectActualTypealias.kt") public void testExpectActualTypealias() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualTypealias.kt"); } + @Test @TestMetadata("expectInterfaceInSupertypes.kt") public void testExpectInterfaceInSupertypes() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectInterfaceInSupertypes.kt"); } + @Test @TestMetadata("expectInterfaceInSupertypes2.kt") public void testExpectInterfaceInSupertypes2() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectInterfaceInSupertypes2.kt"); } + @Test @TestMetadata("expectProperty.kt") public void testExpectProperty() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectProperty.kt"); } + @Test @TestMetadata("fakeOverridesInPlatformModule.kt") public void testFakeOverridesInPlatformModule() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/fakeOverridesInPlatformModule.kt"); } + @Test @TestMetadata("independentCommonSourceModules.kt") public void testIndependentCommonSourceModules() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/independentCommonSourceModules.kt"); } + @Test @TestMetadata("interfaceMethodFromSuperTypeIsImplementedInOtherExpectSuperClass.kt") public void testInterfaceMethodFromSuperTypeIsImplementedInOtherExpectSuperClass() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/interfaceMethodFromSuperTypeIsImplementedInOtherExpectSuperClass.kt"); } + @Test @TestMetadata("kt-56329.kt") public void testKt_56329() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/kt-56329.kt"); } + @Test @TestMetadata("nonExternalEquals.kt") public void testNonExternalEquals() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/nonExternalEquals.kt"); } + @Test @TestMetadata("overridesOfExpectMembers.kt") public void testOverridesOfExpectMembers() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/overridesOfExpectMembers.kt"); } + @Test @TestMetadata("removeExpectDeclarationsFromMetadata.kt") public void testRemoveExpectDeclarationsFromMetadata() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt"); } + @Test @TestMetadata("transitiveSuperclassActualization.kt") public void testTransitiveSuperclassActualization() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/transitiveSuperclassActualization.kt"); } + @Test @TestMetadata("widerVisibilityInActualClassifier.kt") public void testWiderVisibilityInActualClassifier() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/basic/widerVisibilityInActualClassifier.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/multiplatform/k2/defaultArguments") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DefaultArguments extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DefaultArguments { + @Test public void testAllFilesPresentInDefaultArguments() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/k2/defaultArguments"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("bothInExpectAndActual.kt") public void testBothInExpectAndActual() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/bothInExpectAndActual.kt"); } + @Test @TestMetadata("bothInExpectAndActual2.kt") public void testBothInExpectAndActual2() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/bothInExpectAndActual2.kt"); } + @Test @TestMetadata("constructor.kt") public void testConstructor() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/constructor.kt"); } + @Test @TestMetadata("delegatedExpectedInterface.kt") public void testDelegatedExpectedInterface() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/delegatedExpectedInterface.kt"); } + @Test @TestMetadata("dispatchReceiverValue.kt") public void testDispatchReceiverValue() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/dispatchReceiverValue.kt"); } + @Test @TestMetadata("expectPropertyAsDefaultArgument.kt") public void testExpectPropertyAsDefaultArgument() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/expectPropertyAsDefaultArgument.kt"); } + @Test @TestMetadata("extensionReceiverValue.kt") public void testExtensionReceiverValue() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/extensionReceiverValue.kt"); } + @Test @TestMetadata("function.kt") public void testFunction() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/function.kt"); } + @Test @TestMetadata("functionFromOtherModule.kt") public void testFunctionFromOtherModule() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/functionFromOtherModule.kt"); } + @Test @TestMetadata("inheritedFromCommonClass.kt") public void testInheritedFromCommonClass() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/inheritedFromCommonClass.kt"); } + @Test @TestMetadata("inheritedFromExpectedClass.kt") public void testInheritedFromExpectedClass() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/inheritedFromExpectedClass.kt"); } + @Test @TestMetadata("inheritedFromExpectedInterface.kt") public void testInheritedFromExpectedInterface() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/inheritedFromExpectedInterface.kt"); } + @Test @TestMetadata("inheritedFromExpectedMethod.kt") public void testInheritedFromExpectedMethod() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/inheritedFromExpectedMethod.kt"); } + @Test @TestMetadata("inheritedInExpectedDeclarations.kt") public void testInheritedInExpectedDeclarations() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/inheritedInExpectedDeclarations.kt"); } + @Test @TestMetadata("inheritedViaAnotherInterfaceIndirectly.kt") public void testInheritedViaAnotherInterfaceIndirectly() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/inheritedViaAnotherInterfaceIndirectly.kt"); } + @Test @TestMetadata("inlineFunctionWithDefaultLambda.kt") public void testInlineFunctionWithDefaultLambda() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/inlineFunctionWithDefaultLambda.kt"); } + @Test @TestMetadata("kt23239.kt") public void testKt23239() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/kt23239.kt"); } + @Test @TestMetadata("kt23739.kt") public void testKt23739() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/kt23739.kt"); } + @Test @TestMetadata("nestedEnumEntryValue.kt") public void testNestedEnumEntryValue() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/nestedEnumEntryValue.kt"); } + @Test @TestMetadata("parametersInArgumentValues.kt") public void testParametersInArgumentValues() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/parametersInArgumentValues.kt"); } + @Test @TestMetadata("superCall.kt") public void testSuperCall() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/superCall.kt"); } + @Test @TestMetadata("suspend.kt") public void testSuspend() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/suspend.kt"); } + @Test @TestMetadata("typeAlias.kt") public void testTypeAlias() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/typeAlias.kt"); } + @Test @TestMetadata("withTypeParameter.kt") public void testWithTypeParameter() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/withTypeParameter.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/multiplatform/k2/migratedOldTests") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class MigratedOldTests extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class MigratedOldTests { + @Test public void testAllFilesPresentInMigratedOldTests() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/k2/migratedOldTests"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("mpp1.kt") public void testMpp1() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/migratedOldTests/mpp1.kt"); } + @Test @TestMetadata("mpp2.kt") public void testMpp2() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/migratedOldTests/mpp2.kt"); } + @Test @TestMetadata("mpp_default_args.kt") public void testMpp_default_args() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/migratedOldTests/mpp_default_args.kt"); } + @Test @TestMetadata("mpp_optional_expectation.kt") public void testMpp_optional_expectation() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/migratedOldTests/mpp_optional_expectation.kt"); } + @Test @TestMetadata("remap_expect_property_ref.kt") public void testRemap_expect_property_ref() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/k2/migratedOldTests/remap_expect_property_ref.kt"); @@ -21008,66 +23493,68 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/multiplatform/migratedOldTests") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class MigratedOldTests extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class MigratedOldTests { + @Test public void testAllFilesPresentInMigratedOldTests() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/migratedOldTests"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("mpp1.kt") public void testMpp1() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/migratedOldTests/mpp1.kt"); } + @Test @TestMetadata("mpp2.kt") public void testMpp2() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/migratedOldTests/mpp2.kt"); } + @Test @TestMetadata("mpp_default_args.kt") public void testMpp_default_args() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/migratedOldTests/mpp_default_args.kt"); } + @Test @TestMetadata("remap_expect_property_ref.kt") public void testRemap_expect_property_ref() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/migratedOldTests/remap_expect_property_ref.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/multiplatform/multiModule") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class MultiModule extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class MultiModule { + @Test public void testAllFilesPresentInMultiModule() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/multiModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("defaultArgument.kt") public void testDefaultArgument() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/multiModule/defaultArgument.kt"); } + @Test @TestMetadata("expectActualLink.kt") public void testExpectActualLink() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/multiModule/expectActualLink.kt"); } + @Test @TestMetadata("expectActualMemberLink.kt") public void testExpectActualMemberLink() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/multiModule/expectActualMemberLink.kt"); } + @Test @TestMetadata("expectActualTypealiasLink.kt") public void testExpectActualTypealiasLink() throws Exception { runTest("compiler/testData/codegen/box/multiplatform/multiModule/expectActualTypealiasLink.kt"); @@ -21075,725 +23562,838 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/nonLocalReturns") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NonLocalReturns extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NonLocalReturns { + @Test public void testAllFilesPresentInNonLocalReturns() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nonLocalReturns"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt9644let.kt") public void testKt9644let() throws Exception { runTest("compiler/testData/codegen/box/nonLocalReturns/kt9644let.kt"); } + @Test @TestMetadata("localReturnInsideProperty.kt") public void testLocalReturnInsideProperty() throws Exception { runTest("compiler/testData/codegen/box/nonLocalReturns/localReturnInsideProperty.kt"); } + @Test @TestMetadata("returnInsideTwoLambdas.kt") public void testReturnInsideTwoLambdas() throws Exception { runTest("compiler/testData/codegen/box/nonLocalReturns/returnInsideTwoLambdas.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/notNullAssertions") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NotNullAssertions extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NotNullAssertions { + @Test public void testAllFilesPresentInNotNullAssertions() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/notNullAssertions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/nothingValue") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NothingValue extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NothingValue { + @Test public void testAllFilesPresentInNothingValue() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nothingValue"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("inNestedCall.kt") public void testInNestedCall() throws Exception { runTest("compiler/testData/codegen/box/nothingValue/inNestedCall.kt"); } + @Test @TestMetadata("nothingValueException.kt") public void testNothingValueException() throws Exception { runTest("compiler/testData/codegen/box/nothingValue/nothingValueException.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/nullCheckOptimization") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NullCheckOptimization extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NullCheckOptimization { + @Test public void testAllFilesPresentInNullCheckOptimization() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nullCheckOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("isNullable.kt") public void testIsNullable() throws Exception { runTest("compiler/testData/codegen/box/nullCheckOptimization/isNullable.kt"); } + @Test @TestMetadata("kt22410.kt") public void testKt22410() throws Exception { runTest("compiler/testData/codegen/box/nullCheckOptimization/kt22410.kt"); } + @Test @TestMetadata("kt49136a.kt") public void testKt49136a() throws Exception { runTest("compiler/testData/codegen/box/nullCheckOptimization/kt49136a.kt"); } + @Test @TestMetadata("kt7774.kt") public void testKt7774() throws Exception { runTest("compiler/testData/codegen/box/nullCheckOptimization/kt7774.kt"); } + @Test @TestMetadata("primitiveCheckWithSideEffect.kt") public void testPrimitiveCheckWithSideEffect() throws Exception { runTest("compiler/testData/codegen/box/nullCheckOptimization/primitiveCheckWithSideEffect.kt"); } + @Test @TestMetadata("trivialInstanceOf.kt") public void testTrivialInstanceOf() throws Exception { runTest("compiler/testData/codegen/box/nullCheckOptimization/trivialInstanceOf.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/objectIntrinsics") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ObjectIntrinsics extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ObjectIntrinsics { + @Test public void testAllFilesPresentInObjectIntrinsics() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objectIntrinsics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("objects.kt") public void testObjects() throws Exception { runTest("compiler/testData/codegen/box/objectIntrinsics/objects.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/objects") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Objects extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Objects { + @Test public void testAllFilesPresentInObjects() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("anonymousObjectAndContrvariantProjection.kt") public void testAnonymousObjectAndContrvariantProjection() throws Exception { runTest("compiler/testData/codegen/box/objects/anonymousObjectAndContrvariantProjection.kt"); } + @Test @TestMetadata("anonymousObjectPropertyInitialization.kt") public void testAnonymousObjectPropertyInitialization() throws Exception { runTest("compiler/testData/codegen/box/objects/anonymousObjectPropertyInitialization.kt"); } + @Test @TestMetadata("anonymousObjectReturnsFromTopLevelFun.kt") public void testAnonymousObjectReturnsFromTopLevelFun() throws Exception { runTest("compiler/testData/codegen/box/objects/anonymousObjectReturnsFromTopLevelFun.kt"); } + @Test @TestMetadata("classCallsProtectedInheritedByCompanion.kt") public void testClassCallsProtectedInheritedByCompanion() throws Exception { runTest("compiler/testData/codegen/box/objects/classCallsProtectedInheritedByCompanion.kt"); } + @Test @TestMetadata("classCompanion.kt") public void testClassCompanion() throws Exception { runTest("compiler/testData/codegen/box/objects/classCompanion.kt"); } + @Test @TestMetadata("compoundAssignmentToArrayAccessToExtensionPropertyImportedFromObject.kt") public void testCompoundAssignmentToArrayAccessToExtensionPropertyImportedFromObject() throws Exception { runTest("compiler/testData/codegen/box/objects/compoundAssignmentToArrayAccessToExtensionPropertyImportedFromObject.kt"); } + @Test @TestMetadata("compoundAssignmentToArrayAccessToPropertyImportedFromObject.kt") public void testCompoundAssignmentToArrayAccessToPropertyImportedFromObject() throws Exception { runTest("compiler/testData/codegen/box/objects/compoundAssignmentToArrayAccessToPropertyImportedFromObject.kt"); } + @Test @TestMetadata("compoundAssignmentToExtensionPropertyImportedFromObject.kt") public void testCompoundAssignmentToExtensionPropertyImportedFromObject() throws Exception { runTest("compiler/testData/codegen/box/objects/compoundAssignmentToExtensionPropertyImportedFromObject.kt"); } + @Test @TestMetadata("compoundAssignmentToObjectFromCall.kt") public void testCompoundAssignmentToObjectFromCall() throws Exception { runTest("compiler/testData/codegen/box/objects/compoundAssignmentToObjectFromCall.kt"); } + @Test @TestMetadata("compoundAssignmentToPropertyImportedFromObject.kt") public void testCompoundAssignmentToPropertyImportedFromObject() throws Exception { runTest("compiler/testData/codegen/box/objects/compoundAssignmentToPropertyImportedFromObject.kt"); } + @Test @TestMetadata("compoundAssignmentToPropertyWithQualifier.kt") public void testCompoundAssignmentToPropertyWithQualifier() throws Exception { runTest("compiler/testData/codegen/box/objects/compoundAssignmentToPropertyWithQualifier.kt"); } + @Test @TestMetadata("flist.kt") public void testFlist() throws Exception { runTest("compiler/testData/codegen/box/objects/flist.kt"); } + @Test @TestMetadata("initializationOrder.kt") public void testInitializationOrder() throws Exception { runTest("compiler/testData/codegen/box/objects/initializationOrder.kt"); } + @Test @TestMetadata("initializationOrderConsts.kt") public void testInitializationOrderConsts() throws Exception { runTest("compiler/testData/codegen/box/objects/initializationOrderConsts.kt"); } + @Test @TestMetadata("initializerBlockResetToDefault.kt") public void testInitializerBlockResetToDefault() throws Exception { runTest("compiler/testData/codegen/box/objects/initializerBlockResetToDefault.kt"); } + @Test @TestMetadata("interfaceCompanion.kt") public void testInterfaceCompanion() throws Exception { runTest("compiler/testData/codegen/box/objects/interfaceCompanion.kt"); } + @Test @TestMetadata("interfaceCompanionObjectReference.kt") public void testInterfaceCompanionObjectReference() throws Exception { runTest("compiler/testData/codegen/box/objects/interfaceCompanionObjectReference.kt"); } - @TestMetadata("kt1047a.kt") - public void testKt1047a() throws Exception { - runTest("compiler/testData/codegen/box/objects/kt1047a.kt"); + @Test + @TestMetadata("kt1047.kt") + public void testKt1047() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt1047.kt"); } + @Test @TestMetadata("kt11117.kt") public void testKt11117() throws Exception { runTest("compiler/testData/codegen/box/objects/kt11117.kt"); } + @Test @TestMetadata("kt1186.kt") public void testKt1186() throws Exception { runTest("compiler/testData/codegen/box/objects/kt1186.kt"); } + @Test @TestMetadata("kt1600.kt") public void testKt1600() throws Exception { runTest("compiler/testData/codegen/box/objects/kt1600.kt"); } + @Test + @TestMetadata("kt1737.kt") + public void testKt1737() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt1737.kt"); + } + + @Test @TestMetadata("kt18982.kt") public void testKt18982() throws Exception { runTest("compiler/testData/codegen/box/objects/kt18982.kt"); } + @Test @TestMetadata("kt2398.kt") public void testKt2398() throws Exception { runTest("compiler/testData/codegen/box/objects/kt2398.kt"); } + @Test @TestMetadata("kt2663.kt") public void testKt2663() throws Exception { runTest("compiler/testData/codegen/box/objects/kt2663.kt"); } + @Test + @TestMetadata("kt2663_2.kt") + public void testKt2663_2() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt2663_2.kt"); + } + + @Test @TestMetadata("kt2663_3.kt") public void testKt2663_3() throws Exception { runTest("compiler/testData/codegen/box/objects/kt2663_3.kt"); } + @Test @TestMetadata("kt2675.kt") public void testKt2675() throws Exception { runTest("compiler/testData/codegen/box/objects/kt2675.kt"); } + @Test @TestMetadata("kt2719.kt") public void testKt2719() throws Exception { runTest("compiler/testData/codegen/box/objects/kt2719.kt"); } + @Test @TestMetadata("kt2822.kt") public void testKt2822() throws Exception { runTest("compiler/testData/codegen/box/objects/kt2822.kt"); } + @Test @TestMetadata("kt32351.kt") public void testKt32351() throws Exception { runTest("compiler/testData/codegen/box/objects/kt32351.kt"); } + @Test + @TestMetadata("kt3238.kt") + public void testKt3238() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt3238.kt"); + } + + @Test @TestMetadata("kt32749.kt") public void testKt32749() throws Exception { runTest("compiler/testData/codegen/box/objects/kt32749.kt"); } + @Test @TestMetadata("kt3684.kt") public void testKt3684() throws Exception { runTest("compiler/testData/codegen/box/objects/kt3684.kt"); } + @Test @TestMetadata("kt4086.kt") public void testKt4086() throws Exception { runTest("compiler/testData/codegen/box/objects/kt4086.kt"); } + @Test @TestMetadata("kt45170.kt") public void testKt45170() throws Exception { runTest("compiler/testData/codegen/box/objects/kt45170.kt"); } + @Test @TestMetadata("kt46136.kt") public void testKt46136() throws Exception { runTest("compiler/testData/codegen/box/objects/kt46136.kt"); } + @Test @TestMetadata("kt52540.kt") public void testKt52540() throws Exception { runTest("compiler/testData/codegen/box/objects/kt52540.kt"); } + @Test @TestMetadata("kt535.kt") public void testKt535() throws Exception { runTest("compiler/testData/codegen/box/objects/kt535.kt"); } + @Test @TestMetadata("kt694.kt") public void testKt694() throws Exception { runTest("compiler/testData/codegen/box/objects/kt694.kt"); } + @Test @TestMetadata("localFunctionInObjectInitializer_kt4516.kt") public void testLocalFunctionInObjectInitializer_kt4516() throws Exception { runTest("compiler/testData/codegen/box/objects/localFunctionInObjectInitializer_kt4516.kt"); } + @Test @TestMetadata("methodOnObject.kt") public void testMethodOnObject() throws Exception { runTest("compiler/testData/codegen/box/objects/methodOnObject.kt"); } + @Test @TestMetadata("nestedDerivedClassCallsProtectedFromCompanion.kt") public void testNestedDerivedClassCallsProtectedFromCompanion() throws Exception { runTest("compiler/testData/codegen/box/objects/nestedDerivedClassCallsProtectedFromCompanion.kt"); } + @Test @TestMetadata("nestedObjectWithSuperclass.kt") public void testNestedObjectWithSuperclass() throws Exception { runTest("compiler/testData/codegen/box/objects/nestedObjectWithSuperclass.kt"); } + @Test @TestMetadata("object.kt") public void testObject() throws Exception { runTest("compiler/testData/codegen/box/objects/object.kt"); } + @Test @TestMetadata("objectExtendsInnerAndReferencesOuterMember.kt") public void testObjectExtendsInnerAndReferencesOuterMember() throws Exception { runTest("compiler/testData/codegen/box/objects/objectExtendsInnerAndReferencesOuterMember.kt"); } + @Test @TestMetadata("objectInLocalAnonymousObject.kt") public void testObjectInLocalAnonymousObject() throws Exception { runTest("compiler/testData/codegen/box/objects/objectInLocalAnonymousObject.kt"); } + @Test @TestMetadata("objectInitialization_kt5523.kt") public void testObjectInitialization_kt5523() throws Exception { runTest("compiler/testData/codegen/box/objects/objectInitialization_kt5523.kt"); } + @Test @TestMetadata("objectLiteral.kt") public void testObjectLiteral() throws Exception { runTest("compiler/testData/codegen/box/objects/objectLiteral.kt"); } + @Test @TestMetadata("objectLiteralInClass.kt") public void testObjectLiteralInClass() throws Exception { runTest("compiler/testData/codegen/box/objects/objectLiteralInClass.kt"); } + @Test @TestMetadata("objectLiteralInClosure.kt") public void testObjectLiteralInClosure() throws Exception { runTest("compiler/testData/codegen/box/objects/objectLiteralInClosure.kt"); } + @Test @TestMetadata("objectVsClassInitialization_kt5291.kt") public void testObjectVsClassInitialization_kt5291() throws Exception { runTest("compiler/testData/codegen/box/objects/objectVsClassInitialization_kt5291.kt"); } + @Test @TestMetadata("objectWithSuperclass.kt") public void testObjectWithSuperclass() throws Exception { runTest("compiler/testData/codegen/box/objects/objectWithSuperclass.kt"); } + @Test @TestMetadata("objectWithSuperclassAndTrait.kt") public void testObjectWithSuperclassAndTrait() throws Exception { runTest("compiler/testData/codegen/box/objects/objectWithSuperclassAndTrait.kt"); } + @Test @TestMetadata("privateExtensionFromInitializer_kt4543.kt") public void testPrivateExtensionFromInitializer_kt4543() throws Exception { runTest("compiler/testData/codegen/box/objects/privateExtensionFromInitializer_kt4543.kt"); } + @Test @TestMetadata("privateFunctionFromClosureInInitializer_kt5582.kt") public void testPrivateFunctionFromClosureInInitializer_kt5582() throws Exception { runTest("compiler/testData/codegen/box/objects/privateFunctionFromClosureInInitializer_kt5582.kt"); } + @Test @TestMetadata("receiverInConstructor.kt") public void testReceiverInConstructor() throws Exception { runTest("compiler/testData/codegen/box/objects/receiverInConstructor.kt"); } + @Test @TestMetadata("safeAccess.kt") public void testSafeAccess() throws Exception { runTest("compiler/testData/codegen/box/objects/safeAccess.kt"); } + @Test @TestMetadata("selfReferenceToCompanionObjectInAnonymousObjectInSuperConstructorCall.kt") public void testSelfReferenceToCompanionObjectInAnonymousObjectInSuperConstructorCall() throws Exception { runTest("compiler/testData/codegen/box/objects/selfReferenceToCompanionObjectInAnonymousObjectInSuperConstructorCall.kt"); } + @Test @TestMetadata("selfReferenceToCompanionObjectInInlineLambdaInConstructorBody.kt") public void testSelfReferenceToCompanionObjectInInlineLambdaInConstructorBody() throws Exception { runTest("compiler/testData/codegen/box/objects/selfReferenceToCompanionObjectInInlineLambdaInConstructorBody.kt"); } + @Test @TestMetadata("selfReferenceToCompanionObjectInInlineLambdaInSuperConstructorCall.kt") public void testSelfReferenceToCompanionObjectInInlineLambdaInSuperConstructorCall() throws Exception { runTest("compiler/testData/codegen/box/objects/selfReferenceToCompanionObjectInInlineLambdaInSuperConstructorCall.kt"); } + @Test @TestMetadata("selfReferenceToCompanionObjectInLambdaInSuperConstructorCall.kt") public void testSelfReferenceToCompanionObjectInLambdaInSuperConstructorCall() throws Exception { runTest("compiler/testData/codegen/box/objects/selfReferenceToCompanionObjectInLambdaInSuperConstructorCall.kt"); } + @Test @TestMetadata("selfReferenceToInterfaceCompanionObjectInAnonymousObjectInSuperConstructorCall.kt") public void testSelfReferenceToInterfaceCompanionObjectInAnonymousObjectInSuperConstructorCall() throws Exception { runTest("compiler/testData/codegen/box/objects/selfReferenceToInterfaceCompanionObjectInAnonymousObjectInSuperConstructorCall.kt"); } + @Test @TestMetadata("selfReferenceToInterfaceCompanionObjectInInlineLambdaInConstructorBody.kt") public void testSelfReferenceToInterfaceCompanionObjectInInlineLambdaInConstructorBody() throws Exception { runTest("compiler/testData/codegen/box/objects/selfReferenceToInterfaceCompanionObjectInInlineLambdaInConstructorBody.kt"); } + @Test @TestMetadata("selfReferenceToInterfaceCompanionObjectInInlineLambdaInSuperConstructorCall.kt") public void testSelfReferenceToInterfaceCompanionObjectInInlineLambdaInSuperConstructorCall() throws Exception { runTest("compiler/testData/codegen/box/objects/selfReferenceToInterfaceCompanionObjectInInlineLambdaInSuperConstructorCall.kt"); } + @Test @TestMetadata("selfReferenceToInterfaceCompanionObjectInLambdaInSuperConstructorCall.kt") public void testSelfReferenceToInterfaceCompanionObjectInLambdaInSuperConstructorCall() throws Exception { runTest("compiler/testData/codegen/box/objects/selfReferenceToInterfaceCompanionObjectInLambdaInSuperConstructorCall.kt"); } + @Test @TestMetadata("selfReferenceToObjectInAnonymousObjectInSuperConstructorCall.kt") public void testSelfReferenceToObjectInAnonymousObjectInSuperConstructorCall() throws Exception { runTest("compiler/testData/codegen/box/objects/selfReferenceToObjectInAnonymousObjectInSuperConstructorCall.kt"); } + @Test @TestMetadata("selfReferenceToObjectInInlineLambdaInConstructorBody.kt") public void testSelfReferenceToObjectInInlineLambdaInConstructorBody() throws Exception { runTest("compiler/testData/codegen/box/objects/selfReferenceToObjectInInlineLambdaInConstructorBody.kt"); } + @Test @TestMetadata("selfReferenceToObjectInInlineLambdaInSuperConstructorCall.kt") public void testSelfReferenceToObjectInInlineLambdaInSuperConstructorCall() throws Exception { runTest("compiler/testData/codegen/box/objects/selfReferenceToObjectInInlineLambdaInSuperConstructorCall.kt"); } + @Test @TestMetadata("selfReferenceToObjectInLambdaInSuperConstructorCall.kt") public void testSelfReferenceToObjectInLambdaInSuperConstructorCall() throws Exception { runTest("compiler/testData/codegen/box/objects/selfReferenceToObjectInLambdaInSuperConstructorCall.kt"); } + @Test @TestMetadata("simpleObject.kt") public void testSimpleObject() throws Exception { runTest("compiler/testData/codegen/box/objects/simpleObject.kt"); } + @Test @TestMetadata("substitutionFunctionFromSuper.kt") public void testSubstitutionFunctionFromSuper() throws Exception { runTest("compiler/testData/codegen/box/objects/substitutionFunctionFromSuper.kt"); } + @Test @TestMetadata("thisInConstructor.kt") public void testThisInConstructor() throws Exception { runTest("compiler/testData/codegen/box/objects/thisInConstructor.kt"); } + @Test @TestMetadata("thisRefToObjectInNestedClassConstructorCall.kt") public void testThisRefToObjectInNestedClassConstructorCall() throws Exception { runTest("compiler/testData/codegen/box/objects/thisRefToObjectInNestedClassConstructorCall.kt"); } + @Test @TestMetadata("useAnonymousObjectAsIterator.kt") public void testUseAnonymousObjectAsIterator() throws Exception { runTest("compiler/testData/codegen/box/objects/useAnonymousObjectAsIterator.kt"); } + @Test @TestMetadata("useAnonymousObjectFunction.kt") public void testUseAnonymousObjectFunction() throws Exception { runTest("compiler/testData/codegen/box/objects/useAnonymousObjectFunction.kt"); } + @Test @TestMetadata("useImportedMember.kt") public void testUseImportedMember() throws Exception { runTest("compiler/testData/codegen/box/objects/useImportedMember.kt"); } + @Test @TestMetadata("useImportedMemberFromCompanion.kt") public void testUseImportedMemberFromCompanion() throws Exception { runTest("compiler/testData/codegen/box/objects/useImportedMemberFromCompanion.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/objects/companionObjectAccess") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class CompanionObjectAccess extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class CompanionObjectAccess { + @Test public void testAllFilesPresentInCompanionObjectAccess() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt27117.kt") public void testKt27117() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/kt27117.kt"); } + @Test @TestMetadata("kt27117_lv12.kt") public void testKt27117_lv12() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/kt27117_lv12.kt"); } + @Test @TestMetadata("kt27117_lv13.kt") public void testKt27117_lv13() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/kt27117_lv13.kt"); } + @Test @TestMetadata("kt27121.kt") public void testKt27121() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/kt27121.kt"); } + @Test @TestMetadata("kt27121_lv12.kt") public void testKt27121_lv12() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/kt27121_lv12.kt"); } + @Test @TestMetadata("kt27121_lv13.kt") public void testKt27121_lv13() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/kt27121_lv13.kt"); } + @Test @TestMetadata("privateCompanionObjectAccessedFromAnonymousObjectInNestedClass.kt") public void testPrivateCompanionObjectAccessedFromAnonymousObjectInNestedClass() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/privateCompanionObjectAccessedFromAnonymousObjectInNestedClass.kt"); } + @Test @TestMetadata("privateCompanionObjectAccessedFromInitBlock.kt") public void testPrivateCompanionObjectAccessedFromInitBlock() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/privateCompanionObjectAccessedFromInitBlock.kt"); } + @Test @TestMetadata("privateCompanionObjectAccessedFromInitBlockOfNestedClass.kt") public void testPrivateCompanionObjectAccessedFromInitBlockOfNestedClass() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/privateCompanionObjectAccessedFromInitBlockOfNestedClass.kt"); } + @Test @TestMetadata("privateCompanionObjectAccessedFromInlineLambdaInNestedClass.kt") public void testPrivateCompanionObjectAccessedFromInlineLambdaInNestedClass() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/privateCompanionObjectAccessedFromInlineLambdaInNestedClass.kt"); } + @Test @TestMetadata("privateCompanionObjectAccessedFromLambdaInNestedClass.kt") public void testPrivateCompanionObjectAccessedFromLambdaInNestedClass() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/privateCompanionObjectAccessedFromLambdaInNestedClass.kt"); } + @Test @TestMetadata("privateCompanionObjectAccessedFromMethodInlinedInNestedClass.kt") public void testPrivateCompanionObjectAccessedFromMethodInlinedInNestedClass() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/privateCompanionObjectAccessedFromMethodInlinedInNestedClass.kt"); } + @Test @TestMetadata("privateCompanionObjectAccessedFromNestedClass.kt") public void testPrivateCompanionObjectAccessedFromNestedClass() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/privateCompanionObjectAccessedFromNestedClass.kt"); } + @Test @TestMetadata("privateCompanionObjectAccessedFromNestedClassSeveralTimes.kt") public void testPrivateCompanionObjectAccessedFromNestedClassSeveralTimes() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/privateCompanionObjectAccessedFromNestedClassSeveralTimes.kt"); } + @Test @TestMetadata("privateCompanionObjectUsedInNestedClass.kt") public void testPrivateCompanionObjectUsedInNestedClass() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/privateCompanionObjectUsedInNestedClass.kt"); } + @Test @TestMetadata("protectedCompanionObjectAccessedFromNestedClass.kt") public void testProtectedCompanionObjectAccessedFromNestedClass() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/protectedCompanionObjectAccessedFromNestedClass.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class MultipleCompanionsWithAccessors extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class MultipleCompanionsWithAccessors { + @Test @TestMetadata("accessFromInlineLambda.kt") public void testAccessFromInlineLambda() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/accessFromInlineLambda.kt"); } + @Test public void testAllFilesPresentInMultipleCompanionsWithAccessors() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("anonymousObjectInPropertyInitializer.kt") public void testAnonymousObjectInPropertyInitializer() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/anonymousObjectInPropertyInitializer.kt"); } + @Test @TestMetadata("fromAnonymousObjectInNestedClass.kt") public void testFromAnonymousObjectInNestedClass() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromAnonymousObjectInNestedClass.kt"); } + @Test @TestMetadata("fromInitBlock.kt") public void testFromInitBlock() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInitBlock.kt"); } + @Test @TestMetadata("fromInitBlockOfNestedClass.kt") public void testFromInitBlockOfNestedClass() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInitBlockOfNestedClass.kt"); } + @Test @TestMetadata("fromInlineLambdaInNestedClass.kt") public void testFromInlineLambdaInNestedClass() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInlineLambdaInNestedClass.kt"); } + @Test @TestMetadata("inheritedProtectedCompanionAndOwnPrivateCompanion.kt") public void testInheritedProtectedCompanionAndOwnPrivateCompanion() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/inheritedProtectedCompanionAndOwnPrivateCompanion.kt"); } + @Test @TestMetadata("inheritedProtectedCompanionsReferencedByName.kt") public void testInheritedProtectedCompanionsReferencedByName() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/inheritedProtectedCompanionsReferencedByName.kt"); } + @Test @TestMetadata("lambdaInPropertyInitializer.kt") public void testLambdaInPropertyInitializer() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/lambdaInPropertyInitializer.kt"); } + @Test @TestMetadata("twoInheritedProtectedCompanions.kt") public void testTwoInheritedProtectedCompanions() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/twoInheritedProtectedCompanions.kt"); } + @Test @TestMetadata("withCompanionObjectBase.kt") public void testWithCompanionObjectBase() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/withCompanionObjectBase.kt"); } + @Test @TestMetadata("withMultipleNestedCompanionObjectBases.kt") public void testWithMultipleNestedCompanionObjectBases() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/withMultipleNestedCompanionObjectBases.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class PrimitiveCompanion extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class PrimitiveCompanion { + @Test public void testAllFilesPresentInPrimitiveCompanion() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("byteCompanionObject.kt") public void testByteCompanionObject() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion/byteCompanionObject.kt"); } + @Test @TestMetadata("charCompanionObject.kt") public void testCharCompanionObject() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion/charCompanionObject.kt"); } + @Test @TestMetadata("doubleCompanionObject.kt") public void testDoubleCompanionObject() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion/doubleCompanionObject.kt"); } + @Test @TestMetadata("floatCompanionObject.kt") public void testFloatCompanionObject() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion/floatCompanionObject.kt"); } + @Test @TestMetadata("intCompanionObject.kt") public void testIntCompanionObject() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion/intCompanionObject.kt"); } + @Test @TestMetadata("longCompanionObject.kt") public void testLongCompanionObject() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion/longCompanionObject.kt"); } + @Test @TestMetadata("shortCompanionObject.kt") public void testShortCompanionObject() throws Exception { runTest("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion/shortCompanionObject.kt"); @@ -21802,210 +24402,241 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/operatorConventions") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class OperatorConventions extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class OperatorConventions { + @Test public void testAllFilesPresentInOperatorConventions() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("annotatedAssignment.kt") public void testAnnotatedAssignment() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/annotatedAssignment.kt"); } + @Test @TestMetadata("assignmentOperations.kt") public void testAssignmentOperations() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/assignmentOperations.kt"); } + @Test @TestMetadata("augmentedAssignmentInInitializer.kt") public void testAugmentedAssignmentInInitializer() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/augmentedAssignmentInInitializer.kt"); } + @Test @TestMetadata("augmentedAssignmentWithArrayLHS.kt") public void testAugmentedAssignmentWithArrayLHS() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/augmentedAssignmentWithArrayLHS.kt"); } + @Test @TestMetadata("genericArrayAccessCall.kt") public void testGenericArrayAccessCall() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/genericArrayAccessCall.kt"); } + @Test @TestMetadata("incDecOnObject.kt") public void testIncDecOnObject() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/incDecOnObject.kt"); } + @Test @TestMetadata("infixFunctionOverBuiltinMember.kt") public void testInfixFunctionOverBuiltinMember() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/infixFunctionOverBuiltinMember.kt"); } + @Test @TestMetadata("kt14201.kt") public void testKt14201() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/kt14201.kt"); } + @Test @TestMetadata("kt14201_2.kt") public void testKt14201_2() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/kt14201_2.kt"); } + @Test @TestMetadata("kt14227.kt") public void testKt14227() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/kt14227.kt"); } + @Test @TestMetadata("kt20387.kt") public void testKt20387() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/kt20387.kt"); } + @Test @TestMetadata("kt39880.kt") public void testKt39880() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/kt39880.kt"); } + @Test @TestMetadata("kt4152.kt") public void testKt4152() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/kt4152.kt"); } + @Test @TestMetadata("kt42722.kt") public void testKt42722() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/kt42722.kt"); } + @Test @TestMetadata("kt44647.kt") public void testKt44647() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/kt44647.kt"); } + @Test @TestMetadata("kt45022.kt") public void testKt45022() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/kt45022.kt"); } + @Test @TestMetadata("kt4987.kt") public void testKt4987() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/kt4987.kt"); } + @Test @TestMetadata("nestedMaps.kt") public void testNestedMaps() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/nestedMaps.kt"); } + @Test @TestMetadata("operatorSetLambda.kt") public void testOperatorSetLambda() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/operatorSetLambda.kt"); } + @Test @TestMetadata("overloadedSet.kt") public void testOverloadedSet() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/overloadedSet.kt"); } + @Test @TestMetadata("plusAssignWithComplexRHS.kt") public void testPlusAssignWithComplexRHS() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/plusAssignWithComplexRHS.kt"); } + @Test @TestMetadata("plusExplicit.kt") public void testPlusExplicit() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/plusExplicit.kt"); } + @Test @TestMetadata("remAssignmentOperation.kt") public void testRemAssignmentOperation() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/remAssignmentOperation.kt"); } + @Test @TestMetadata("remOverModOperation.kt") public void testRemOverModOperation() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/remOverModOperation.kt"); } + @Test @TestMetadata("suspendOperators.kt") public void testSuspendOperators() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/suspendOperators.kt"); } + @Test @TestMetadata("untilOperator.kt") public void testUntilOperator() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/untilOperator.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/operatorConventions/compareTo") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class CompareTo extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class CompareTo { + @Test public void testAllFilesPresentInCompareTo() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions/compareTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("boolean.kt") public void testBoolean() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/compareTo/boolean.kt"); } + @Test @TestMetadata("comparable.kt") public void testComparable() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/compareTo/comparable.kt"); } + @Test @TestMetadata("customCompareTo.kt") public void testCustomCompareTo() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/compareTo/customCompareTo.kt"); } + @Test @TestMetadata("doubleInt.kt") public void testDoubleInt() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/compareTo/doubleInt.kt"); } + @Test @TestMetadata("doubleLong.kt") public void testDoubleLong() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/compareTo/doubleLong.kt"); } + @Test @TestMetadata("extensionArray.kt") public void testExtensionArray() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/compareTo/extensionArray.kt"); } + @Test @TestMetadata("extensionObject.kt") public void testExtensionObject() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/compareTo/extensionObject.kt"); } + @Test @TestMetadata("intDouble.kt") public void testIntDouble() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/compareTo/intDouble.kt"); } + @Test @TestMetadata("intLong.kt") public void testIntLong() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/compareTo/intLong.kt"); } + @Test @TestMetadata("longDouble.kt") public void testLongDouble() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/compareTo/longDouble.kt"); } + @Test @TestMetadata("longInt.kt") public void testLongInt() throws Exception { runTest("compiler/testData/codegen/box/operatorConventions/compareTo/longInt.kt"); @@ -22013,224 +24644,241 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/optimizations") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Optimizations extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Optimizations { + @Test public void testAllFilesPresentInOptimizations() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/optimizations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt20844.kt") public void testKt20844() throws Exception { runTest("compiler/testData/codegen/box/optimizations/kt20844.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/package") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Package extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Package { + @Test public void testAllFilesPresentInPackage() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/package"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("boxPrimitiveTypeInClinit.kt") public void testBoxPrimitiveTypeInClinit() throws Exception { runTest("compiler/testData/codegen/box/package/boxPrimitiveTypeInClinit.kt"); } + @Test @TestMetadata("checkCast.kt") public void testCheckCast() throws Exception { runTest("compiler/testData/codegen/box/package/checkCast.kt"); } + @Test @TestMetadata("incrementProperty.kt") public void testIncrementProperty() throws Exception { runTest("compiler/testData/codegen/box/package/incrementProperty.kt"); } + @Test @TestMetadata("initializationOrder.kt") public void testInitializationOrder() throws Exception { runTest("compiler/testData/codegen/box/package/initializationOrder.kt"); } + @Test @TestMetadata("invokespecial.kt") public void testInvokespecial() throws Exception { runTest("compiler/testData/codegen/box/package/invokespecial.kt"); } + @Test @TestMetadata("kt57353.kt") public void testKt57353() throws Exception { runTest("compiler/testData/codegen/box/package/kt57353.kt"); } + @Test @TestMetadata("nullablePrimitiveNoFieldInitializer.kt") public void testNullablePrimitiveNoFieldInitializer() throws Exception { runTest("compiler/testData/codegen/box/package/nullablePrimitiveNoFieldInitializer.kt"); } + @Test @TestMetadata("packageLocalClassNotImportedWithDefaultImport.kt") public void testPackageLocalClassNotImportedWithDefaultImport() throws Exception { runTest("compiler/testData/codegen/box/package/packageLocalClassNotImportedWithDefaultImport.kt"); } + @Test @TestMetadata("packageQualifiedMethod.kt") public void testPackageQualifiedMethod() throws Exception { runTest("compiler/testData/codegen/box/package/packageQualifiedMethod.kt"); } + @Test @TestMetadata("privateMembersInImportList.kt") public void testPrivateMembersInImportList() throws Exception { runTest("compiler/testData/codegen/box/package/privateMembersInImportList.kt"); } + @Test @TestMetadata("privateTopLevelPropAndVarInInner.kt") public void testPrivateTopLevelPropAndVarInInner() throws Exception { runTest("compiler/testData/codegen/box/package/privateTopLevelPropAndVarInInner.kt"); } + @Test @TestMetadata("referenceWithTheSameNameAsPackage.kt") public void testReferenceWithTheSameNameAsPackage() throws Exception { runTest("compiler/testData/codegen/box/package/referenceWithTheSameNameAsPackage.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/parametersMetadata") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ParametersMetadata extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ParametersMetadata { + @Test public void testAllFilesPresentInParametersMetadata() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/parametersMetadata"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/platformTypes") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class PlatformTypes extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class PlatformTypes { + @Test public void testAllFilesPresentInPlatformTypes() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/platformTypes/primitives") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Primitives extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Primitives { + @Test public void testAllFilesPresentInPrimitives() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes/primitives"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("assign.kt") public void testAssign() throws Exception { runTest("compiler/testData/codegen/box/platformTypes/primitives/assign.kt"); } + @Test @TestMetadata("compareTo.kt") public void testCompareTo() throws Exception { runTest("compiler/testData/codegen/box/platformTypes/primitives/compareTo.kt"); } + @Test @TestMetadata("dec.kt") public void testDec() throws Exception { runTest("compiler/testData/codegen/box/platformTypes/primitives/dec.kt"); } + @Test @TestMetadata("div.kt") public void testDiv() throws Exception { runTest("compiler/testData/codegen/box/platformTypes/primitives/div.kt"); } + @Test @TestMetadata("equals.kt") public void testEquals() throws Exception { runTest("compiler/testData/codegen/box/platformTypes/primitives/equals.kt"); } + @Test @TestMetadata("hashCode.kt") public void testHashCode() throws Exception { runTest("compiler/testData/codegen/box/platformTypes/primitives/hashCode.kt"); } + @Test @TestMetadata("inc.kt") public void testInc() throws Exception { runTest("compiler/testData/codegen/box/platformTypes/primitives/inc.kt"); } + @Test @TestMetadata("minus.kt") public void testMinus() throws Exception { runTest("compiler/testData/codegen/box/platformTypes/primitives/minus.kt"); } + @Test @TestMetadata("mod.kt") public void testMod() throws Exception { runTest("compiler/testData/codegen/box/platformTypes/primitives/mod.kt"); } + @Test @TestMetadata("not.kt") public void testNot() throws Exception { runTest("compiler/testData/codegen/box/platformTypes/primitives/not.kt"); } + @Test @TestMetadata("notEquals.kt") public void testNotEquals() throws Exception { runTest("compiler/testData/codegen/box/platformTypes/primitives/notEquals.kt"); } + @Test @TestMetadata("plus.kt") public void testPlus() throws Exception { runTest("compiler/testData/codegen/box/platformTypes/primitives/plus.kt"); } + @Test @TestMetadata("plusAssign.kt") public void testPlusAssign() throws Exception { runTest("compiler/testData/codegen/box/platformTypes/primitives/plusAssign.kt"); } + @Test @TestMetadata("rangeTo.kt") public void testRangeTo() throws Exception { runTest("compiler/testData/codegen/box/platformTypes/primitives/rangeTo.kt"); } + @Test @TestMetadata("times.kt") public void testTimes() throws Exception { runTest("compiler/testData/codegen/box/platformTypes/primitives/times.kt"); } + @Test @TestMetadata("toShort.kt") public void testToShort() throws Exception { runTest("compiler/testData/codegen/box/platformTypes/primitives/toShort.kt"); } + @Test @TestMetadata("toString.kt") public void testToString() throws Exception { runTest("compiler/testData/codegen/box/platformTypes/primitives/toString.kt"); } + @Test @TestMetadata("unaryMinus.kt") public void testUnaryMinus() throws Exception { runTest("compiler/testData/codegen/box/platformTypes/primitives/unaryMinus.kt"); } + @Test @TestMetadata("unaryPlus.kt") public void testUnaryPlus() throws Exception { runTest("compiler/testData/codegen/box/platformTypes/primitives/unaryPlus.kt"); @@ -22238,470 +24886,560 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/polymorphicSignature") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class PolymorphicSignature extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class PolymorphicSignature { + @Test public void testAllFilesPresentInPolymorphicSignature() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/polymorphicSignature"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/primitiveTypes") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class PrimitiveTypes extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class PrimitiveTypes { + @Test public void testAllFilesPresentInPrimitiveTypes() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("booleanHashCode.kt") public void testBooleanHashCode() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/booleanHashCode.kt"); } + @Test @TestMetadata("comparisonWithNullCallsFun.kt") public void testComparisonWithNullCallsFun() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/comparisonWithNullCallsFun.kt"); } + @Test @TestMetadata("conversions.kt") public void testConversions() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/conversions.kt"); } + @Test @TestMetadata("ea35963.kt") public void testEa35963() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/ea35963.kt"); } + @Test @TestMetadata("equalsHashCodeToString.kt") public void testEqualsHashCodeToString() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalsHashCodeToString.kt"); } + @Test @TestMetadata("incrementByteCharShort.kt") public void testIncrementByteCharShort() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/incrementByteCharShort.kt"); } + @Test @TestMetadata("intLiteralIsNotNull.kt") public void testIntLiteralIsNotNull() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/intLiteralIsNotNull.kt"); } + @Test @TestMetadata("kt1054.kt") public void testKt1054() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt1054.kt"); } + @Test @TestMetadata("kt1055.kt") public void testKt1055() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt1055.kt"); } + @Test @TestMetadata("kt1093.kt") public void testKt1093() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt1093.kt"); } + @Test @TestMetadata("kt13023.kt") public void testKt13023() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt13023.kt"); } + @Test @TestMetadata("kt14868.kt") public void testKt14868() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt14868.kt"); } + @Test @TestMetadata("kt1508.kt") public void testKt1508() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt1508.kt"); } + @Test @TestMetadata("kt1634.kt") public void testKt1634() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt1634.kt"); } + @Test @TestMetadata("kt16732.kt") public void testKt16732() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt16732.kt"); } + @Test @TestMetadata("kt2251.kt") public void testKt2251() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt2251.kt"); } + @Test @TestMetadata("kt2269.kt") public void testKt2269() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt2269.kt"); } + @Test @TestMetadata("kt2269NotOptimizable.kt") public void testKt2269NotOptimizable() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt2269NotOptimizable.kt"); } + @Test @TestMetadata("kt2275.kt") public void testKt2275() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt2275.kt"); } + @Test @TestMetadata("kt239.kt") public void testKt239() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt239.kt"); } + @Test @TestMetadata("kt242.kt") public void testKt242() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt242.kt"); } + @Test @TestMetadata("kt248.kt") public void testKt248() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt248.kt"); } + @Test @TestMetadata("kt2768.kt") public void testKt2768() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt2768.kt"); } + @Test @TestMetadata("kt2794.kt") public void testKt2794() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt2794.kt"); } + @Test @TestMetadata("kt3078.kt") public void testKt3078() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt3078.kt"); } + @Test @TestMetadata("kt3517.kt") public void testKt3517() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt3517.kt"); } + @Test @TestMetadata("kt3576.kt") public void testKt3576() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt3576.kt"); } + @Test @TestMetadata("kt3613.kt") public void testKt3613() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt3613.kt"); } + @Test @TestMetadata("kt36952_identityEqualsWithBooleanInLocalFunction.kt") public void testKt36952_identityEqualsWithBooleanInLocalFunction() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt36952_identityEqualsWithBooleanInLocalFunction.kt"); } + @Test @TestMetadata("kt37505.kt") public void testKt37505() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt37505.kt"); } + @Test @TestMetadata("kt4097.kt") public void testKt4097() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt4097.kt"); } + @Test @TestMetadata("kt4098.kt") public void testKt4098() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt4098.kt"); } + @Test @TestMetadata("kt4210.kt") public void testKt4210() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt4210.kt"); } + @Test @TestMetadata("kt4251.kt") public void testKt4251() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt4251.kt"); } + @Test @TestMetadata("kt446.kt") public void testKt446() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt446.kt"); } + @Test @TestMetadata("kt46864_double.kt") public void testKt46864_double() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt46864_double.kt"); } + @Test @TestMetadata("kt46864_long.kt") public void testKt46864_long() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt46864_long.kt"); } + @Test @TestMetadata("kt518.kt") public void testKt518() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt518.kt"); } + @Test @TestMetadata("kt6590_identityEquals.kt") public void testKt6590_identityEquals() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt6590_identityEquals.kt"); } + @Test @TestMetadata("kt665.kt") public void testKt665() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt665.kt"); } + @Test + @TestMetadata("kt684.kt") + public void testKt684() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt684.kt"); + } + + @Test @TestMetadata("kt711.kt") public void testKt711() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt711.kt"); } + @Test @TestMetadata("kt737.kt") public void testKt737() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt737.kt"); } + @Test @TestMetadata("kt752.kt") public void testKt752() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt752.kt"); } + @Test @TestMetadata("kt753.kt") public void testKt753() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt753.kt"); } + @Test @TestMetadata("kt756.kt") public void testKt756() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt756.kt"); } + @Test @TestMetadata("kt757.kt") public void testKt757() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt757.kt"); } + @Test @TestMetadata("kt828.kt") public void testKt828() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt828.kt"); } + @Test @TestMetadata("kt877.kt") public void testKt877() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt877.kt"); } + @Test @TestMetadata("kt882.kt") public void testKt882() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt882.kt"); } + @Test @TestMetadata("kt887.kt") public void testKt887() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/kt887.kt"); } + @Test + @TestMetadata("kt935.kt") + public void testKt935() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt935.kt"); + } + + @Test @TestMetadata("nullAsNullableIntIsNull.kt") public void testNullAsNullableIntIsNull() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/nullAsNullableIntIsNull.kt"); } + @Test @TestMetadata("nullableAsIndex.kt") public void testNullableAsIndex() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/nullableAsIndex.kt"); } + @Test @TestMetadata("nullableCharBoolean.kt") public void testNullableCharBoolean() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/nullableCharBoolean.kt"); } + @Test @TestMetadata("numberEqualsHashCodeToString.kt") public void testNumberEqualsHashCodeToString() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/numberEqualsHashCodeToString.kt"); } + @Test @TestMetadata("rangeTo.kt") public void testRangeTo() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/rangeTo.kt"); } + @Test @TestMetadata("stringEqualsHashCodeToString.kt") public void testStringEqualsHashCodeToString() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/stringEqualsHashCodeToString.kt"); } + @Test + @TestMetadata("substituteIntForGeneric.kt") + public void testSubstituteIntForGeneric() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/substituteIntForGeneric.kt"); + } + + @Test @TestMetadata("unboxComparable.kt") public void testUnboxComparable() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/unboxComparable.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/primitiveTypes/equalityWithObject") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class EqualityWithObject extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class EqualityWithObject { + @Test public void testAllFilesPresentInEqualityWithObject() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("boxedEqPrimitiveEvaluationOrder.kt") public void testBoxedEqPrimitiveEvaluationOrder() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/boxedEqPrimitiveEvaluationOrder.kt"); } + @Test @TestMetadata("boxedLongEqualsLong.kt") public void testBoxedLongEqualsLong() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/boxedLongEqualsLong.kt"); } + @Test @TestMetadata("intEqualsNull.kt") public void testIntEqualsNull() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/intEqualsNull.kt"); } + @Test @TestMetadata("intEqualsNullableInt.kt") public void testIntEqualsNullableInt() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/intEqualsNullableInt.kt"); } + @Test @TestMetadata("intEqualsNullableIntWithSmartCasts.kt") public void testIntEqualsNullableIntWithSmartCasts() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/intEqualsNullableIntWithSmartCasts.kt"); } + @Test @TestMetadata("kt42281.kt") public void testKt42281() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/kt42281.kt"); } + @Test @TestMetadata("objectWithAsymmetricEqualsEqPrimitive.kt") public void testObjectWithAsymmetricEqualsEqPrimitive() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/objectWithAsymmetricEqualsEqPrimitive.kt"); } + @Test @TestMetadata("whenIntAsNullableAny.kt") public void testWhenIntAsNullableAny() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/whenIntAsNullableAny.kt"); } + @Test @TestMetadata("whenNullableBoxed.kt") public void testWhenNullableBoxed() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/whenNullableBoxed.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Generated extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Generated { + @Test public void testAllFilesPresentInGenerated() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("boxedEqPrimitiveBoolean.kt") public void testBoxedEqPrimitiveBoolean() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/boxedEqPrimitiveBoolean.kt"); } + @Test @TestMetadata("boxedEqPrimitiveByte.kt") public void testBoxedEqPrimitiveByte() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/boxedEqPrimitiveByte.kt"); } + @Test @TestMetadata("boxedEqPrimitiveChar.kt") public void testBoxedEqPrimitiveChar() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/boxedEqPrimitiveChar.kt"); } + @Test @TestMetadata("boxedEqPrimitiveInt.kt") public void testBoxedEqPrimitiveInt() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/boxedEqPrimitiveInt.kt"); } + @Test @TestMetadata("boxedEqPrimitiveLong.kt") public void testBoxedEqPrimitiveLong() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/boxedEqPrimitiveLong.kt"); } + @Test @TestMetadata("boxedEqPrimitiveShort.kt") public void testBoxedEqPrimitiveShort() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/boxedEqPrimitiveShort.kt"); } + @Test @TestMetadata("primitiveEqBoxedBoolean.kt") public void testPrimitiveEqBoxedBoolean() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/primitiveEqBoxedBoolean.kt"); } + @Test @TestMetadata("primitiveEqBoxedByte.kt") public void testPrimitiveEqBoxedByte() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/primitiveEqBoxedByte.kt"); } + @Test @TestMetadata("primitiveEqBoxedChar.kt") public void testPrimitiveEqBoxedChar() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/primitiveEqBoxedChar.kt"); } + @Test @TestMetadata("primitiveEqBoxedInt.kt") public void testPrimitiveEqBoxedInt() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/primitiveEqBoxedInt.kt"); } + @Test @TestMetadata("primitiveEqBoxedLong.kt") public void testPrimitiveEqBoxedLong() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/primitiveEqBoxedLong.kt"); } + @Test @TestMetadata("primitiveEqBoxedShort.kt") public void testPrimitiveEqBoxedShort() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/primitiveEqBoxedShort.kt"); } + @Test @TestMetadata("primitiveEqObjectBoolean.kt") public void testPrimitiveEqObjectBoolean() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/primitiveEqObjectBoolean.kt"); } + @Test @TestMetadata("primitiveEqObjectByte.kt") public void testPrimitiveEqObjectByte() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/primitiveEqObjectByte.kt"); } + @Test @TestMetadata("primitiveEqObjectChar.kt") public void testPrimitiveEqObjectChar() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/primitiveEqObjectChar.kt"); } + @Test @TestMetadata("primitiveEqObjectInt.kt") public void testPrimitiveEqObjectInt() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/primitiveEqObjectInt.kt"); } + @Test @TestMetadata("primitiveEqObjectLong.kt") public void testPrimitiveEqObjectLong() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/primitiveEqObjectLong.kt"); } + @Test @TestMetadata("primitiveEqObjectShort.kt") public void testPrimitiveEqObjectShort() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/primitiveEqObjectShort.kt"); @@ -22709,43 +25447,46 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/primitiveTypes/numberToChar") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NumberToChar extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NumberToChar { + @Test @TestMetadata("abstractMethodInSuperinterface.kt") public void testAbstractMethodInSuperinterface() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/numberToChar/abstractMethodInSuperinterface.kt"); } + @Test public void testAllFilesPresentInNumberToChar() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/numberToChar"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("fakeOverride.kt") public void testFakeOverride() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/numberToChar/fakeOverride.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/numberToChar/simple.kt"); } + @Test @TestMetadata("superCallToClass.kt") public void testSuperCallToClass() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/numberToChar/superCallToClass.kt"); } + @Test @TestMetadata("superCallToInterface.kt") public void testSuperCallToInterface() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/numberToChar/superCallToInterface.kt"); } + @Test @TestMetadata("superCallToNumber.kt") public void testSuperCallToNumber() throws Exception { runTest("compiler/testData/codegen/box/primitiveTypes/numberToChar/superCallToNumber.kt"); @@ -22753,760 +25494,874 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/private") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Private extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Private { + @Test public void testAllFilesPresentInPrivate() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/private"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("arrayConvention.kt") public void testArrayConvention() throws Exception { runTest("compiler/testData/codegen/box/private/arrayConvention.kt"); } + @Test @TestMetadata("kt9855.kt") public void testKt9855() throws Exception { runTest("compiler/testData/codegen/box/private/kt9855.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/privateConstructors") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class PrivateConstructors extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class PrivateConstructors { + @Test public void testAllFilesPresentInPrivateConstructors() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/privateConstructors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("base.kt") public void testBase() throws Exception { runTest("compiler/testData/codegen/box/privateConstructors/base.kt"); } + @Test @TestMetadata("captured.kt") public void testCaptured() throws Exception { runTest("compiler/testData/codegen/box/privateConstructors/captured.kt"); } + @Test @TestMetadata("companion.kt") public void testCompanion() throws Exception { runTest("compiler/testData/codegen/box/privateConstructors/companion.kt"); } + @Test @TestMetadata("inline.kt") public void testInline() throws Exception { runTest("compiler/testData/codegen/box/privateConstructors/inline.kt"); } + @Test @TestMetadata("inner.kt") public void testInner() throws Exception { runTest("compiler/testData/codegen/box/privateConstructors/inner.kt"); } + @Test @TestMetadata("kt4860.kt") public void testKt4860() throws Exception { runTest("compiler/testData/codegen/box/privateConstructors/kt4860.kt"); } + @Test @TestMetadata("secondary.kt") public void testSecondary() throws Exception { runTest("compiler/testData/codegen/box/privateConstructors/secondary.kt"); } + @Test @TestMetadata("withArguments.kt") public void testWithArguments() throws Exception { runTest("compiler/testData/codegen/box/privateConstructors/withArguments.kt"); } + @Test @TestMetadata("withDefault.kt") public void testWithDefault() throws Exception { runTest("compiler/testData/codegen/box/privateConstructors/withDefault.kt"); } + @Test @TestMetadata("withLinkedClasses.kt") public void testWithLinkedClasses() throws Exception { runTest("compiler/testData/codegen/box/privateConstructors/withLinkedClasses.kt"); } + @Test @TestMetadata("withLinkedObjects.kt") public void testWithLinkedObjects() throws Exception { runTest("compiler/testData/codegen/box/privateConstructors/withLinkedObjects.kt"); } + @Test @TestMetadata("withVarargs.kt") public void testWithVarargs() throws Exception { runTest("compiler/testData/codegen/box/privateConstructors/withVarargs.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/properties") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Properties extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Properties { + @Test @TestMetadata("accessToPrivateProperty.kt") public void testAccessToPrivateProperty() throws Exception { runTest("compiler/testData/codegen/box/properties/accessToPrivateProperty.kt"); } + @Test @TestMetadata("accessToPrivateSetter.kt") public void testAccessToPrivateSetter() throws Exception { runTest("compiler/testData/codegen/box/properties/accessToPrivateSetter.kt"); } + @Test @TestMetadata("accessorForProtectedPropertyWithPrivateSetter.kt") public void testAccessorForProtectedPropertyWithPrivateSetter() throws Exception { runTest("compiler/testData/codegen/box/properties/accessorForProtectedPropertyWithPrivateSetter.kt"); } + @Test @TestMetadata("accessorForProtectedPropertyWithPrivateSetterInObjectLiteral.kt") public void testAccessorForProtectedPropertyWithPrivateSetterInObjectLiteral() throws Exception { runTest("compiler/testData/codegen/box/properties/accessorForProtectedPropertyWithPrivateSetterInObjectLiteral.kt"); } + @Test @TestMetadata("accessorForProtectedPropertyWithPrivateSetterViaSuper.kt") public void testAccessorForProtectedPropertyWithPrivateSetterViaSuper() throws Exception { runTest("compiler/testData/codegen/box/properties/accessorForProtectedPropertyWithPrivateSetterViaSuper.kt"); } + @Test @TestMetadata("accessorForProtectedPropertyWithPrivateSetterWithIntermediateClass.kt") public void testAccessorForProtectedPropertyWithPrivateSetterWithIntermediateClass() throws Exception { runTest("compiler/testData/codegen/box/properties/accessorForProtectedPropertyWithPrivateSetterWithIntermediateClass.kt"); } + @Test public void testAllFilesPresentInProperties() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("augmentedAssignmentsAndIncrements.kt") public void testAugmentedAssignmentsAndIncrements() throws Exception { runTest("compiler/testData/codegen/box/properties/augmentedAssignmentsAndIncrements.kt"); } + @Test @TestMetadata("classArtificialFieldInsideNested.kt") public void testClassArtificialFieldInsideNested() throws Exception { runTest("compiler/testData/codegen/box/properties/classArtificialFieldInsideNested.kt"); } + @Test @TestMetadata("classFieldInsideLambda.kt") public void testClassFieldInsideLambda() throws Exception { runTest("compiler/testData/codegen/box/properties/classFieldInsideLambda.kt"); } + @Test @TestMetadata("classFieldInsideLocalInSetter.kt") public void testClassFieldInsideLocalInSetter() throws Exception { runTest("compiler/testData/codegen/box/properties/classFieldInsideLocalInSetter.kt"); } + @Test @TestMetadata("classFieldInsideNested.kt") public void testClassFieldInsideNested() throws Exception { runTest("compiler/testData/codegen/box/properties/classFieldInsideNested.kt"); } + @Test @TestMetadata("classFieldInsideNestedLambda.kt") public void testClassFieldInsideNestedLambda() throws Exception { runTest("compiler/testData/codegen/box/properties/classFieldInsideNestedLambda.kt"); } + @Test @TestMetadata("classFieldInsideNestedNestedLambda.kt") public void testClassFieldInsideNestedNestedLambda() throws Exception { runTest("compiler/testData/codegen/box/properties/classFieldInsideNestedNestedLambda.kt"); } + @Test @TestMetadata("classObjectProperties.kt") public void testClassObjectProperties() throws Exception { runTest("compiler/testData/codegen/box/properties/classObjectProperties.kt"); } + @Test @TestMetadata("classPrivateArtificialFieldInsideNested.kt") public void testClassPrivateArtificialFieldInsideNested() throws Exception { runTest("compiler/testData/codegen/box/properties/classPrivateArtificialFieldInsideNested.kt"); } + @Test @TestMetadata("companionFieldInsideLambda.kt") public void testCompanionFieldInsideLambda() throws Exception { runTest("compiler/testData/codegen/box/properties/companionFieldInsideLambda.kt"); } + @Test @TestMetadata("companionPrivateField.kt") public void testCompanionPrivateField() throws Exception { runTest("compiler/testData/codegen/box/properties/companionPrivateField.kt"); } + @Test @TestMetadata("companionPrivateFieldInsideLambda.kt") public void testCompanionPrivateFieldInsideLambda() throws Exception { runTest("compiler/testData/codegen/box/properties/companionPrivateFieldInsideLambda.kt"); } + @Test @TestMetadata("complexPropertyInitializer.kt") public void testComplexPropertyInitializer() throws Exception { runTest("compiler/testData/codegen/box/properties/complexPropertyInitializer.kt"); } + @Test @TestMetadata("field.kt") public void testField() throws Exception { runTest("compiler/testData/codegen/box/properties/field.kt"); } + @Test @TestMetadata("fieldInClass.kt") public void testFieldInClass() throws Exception { runTest("compiler/testData/codegen/box/properties/fieldInClass.kt"); } + @Test @TestMetadata("fieldInsideField.kt") public void testFieldInsideField() throws Exception { runTest("compiler/testData/codegen/box/properties/fieldInsideField.kt"); } + @Test @TestMetadata("fieldInsideLambda.kt") public void testFieldInsideLambda() throws Exception { runTest("compiler/testData/codegen/box/properties/fieldInsideLambda.kt"); } + @Test @TestMetadata("fieldInsideNested.kt") public void testFieldInsideNested() throws Exception { runTest("compiler/testData/codegen/box/properties/fieldInsideNested.kt"); } + @Test @TestMetadata("fieldSimple.kt") public void testFieldSimple() throws Exception { runTest("compiler/testData/codegen/box/properties/fieldSimple.kt"); } + @Test @TestMetadata("generalAccess.kt") public void testGeneralAccess() throws Exception { runTest("compiler/testData/codegen/box/properties/generalAccess.kt"); } + @Test @TestMetadata("genericPropertyMultiModule.kt") public void testGenericPropertyMultiModule() throws Exception { runTest("compiler/testData/codegen/box/properties/genericPropertyMultiModule.kt"); } + @Test @TestMetadata("genericWithSameName.kt") public void testGenericWithSameName() throws Exception { runTest("compiler/testData/codegen/box/properties/genericWithSameName.kt"); } + @Test @TestMetadata("initOrderMultiModule.kt") public void testInitOrderMultiModule() throws Exception { runTest("compiler/testData/codegen/box/properties/initOrderMultiModule.kt"); } + @Test @TestMetadata("initializerOfConstValWithConst.kt") public void testInitializerOfConstValWithConst() throws Exception { runTest("compiler/testData/codegen/box/properties/initializerOfConstValWithConst.kt"); } + @Test @TestMetadata("initializerOfConstValWithConstExpr.kt") public void testInitializerOfConstValWithConstExpr() throws Exception { runTest("compiler/testData/codegen/box/properties/initializerOfConstValWithConstExpr.kt"); } + @Test @TestMetadata("initializerOfValWithConstExpr.kt") public void testInitializerOfValWithConstExpr() throws Exception { runTest("compiler/testData/codegen/box/properties/initializerOfValWithConstExpr.kt"); } + @Test @TestMetadata("initializerOfValWithNonConstExpr.kt") public void testInitializerOfValWithNonConstExpr() throws Exception { runTest("compiler/testData/codegen/box/properties/initializerOfValWithNonConstExpr.kt"); } + @Test @TestMetadata("kt10715.kt") public void testKt10715() throws Exception { runTest("compiler/testData/codegen/box/properties/kt10715.kt"); } + @Test @TestMetadata("kt10729.kt") public void testKt10729() throws Exception { runTest("compiler/testData/codegen/box/properties/kt10729.kt"); } + @Test + @TestMetadata("kt1159.kt") + public void testKt1159() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt1159.kt"); + } + + @Test @TestMetadata("kt1165.kt") public void testKt1165() throws Exception { runTest("compiler/testData/codegen/box/properties/kt1165.kt"); } + @Test @TestMetadata("kt1168.kt") public void testKt1168() throws Exception { runTest("compiler/testData/codegen/box/properties/kt1168.kt"); } + @Test @TestMetadata("kt1170.kt") public void testKt1170() throws Exception { runTest("compiler/testData/codegen/box/properties/kt1170.kt"); } + @Test @TestMetadata("kt1398.kt") public void testKt1398() throws Exception { runTest("compiler/testData/codegen/box/properties/kt1398.kt"); } + @Test @TestMetadata("kt1417.kt") public void testKt1417() throws Exception { runTest("compiler/testData/codegen/box/properties/kt1417.kt"); } + @Test + @TestMetadata("kt1714.kt") + public void testKt1714() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt1714.kt"); + } + + @Test @TestMetadata("kt1714_minimal.kt") public void testKt1714_minimal() throws Exception { runTest("compiler/testData/codegen/box/properties/kt1714_minimal.kt"); } + @Test @TestMetadata("kt1892.kt") public void testKt1892() throws Exception { runTest("compiler/testData/codegen/box/properties/kt1892.kt"); } + @Test @TestMetadata("kt2331.kt") public void testKt2331() throws Exception { runTest("compiler/testData/codegen/box/properties/kt2331.kt"); } + @Test @TestMetadata("kt257.kt") public void testKt257() throws Exception { runTest("compiler/testData/codegen/box/properties/kt257.kt"); } + @Test @TestMetadata("kt2655.kt") public void testKt2655() throws Exception { runTest("compiler/testData/codegen/box/properties/kt2655.kt"); } + @Test @TestMetadata("kt2786.kt") public void testKt2786() throws Exception { runTest("compiler/testData/codegen/box/properties/kt2786.kt"); } + @Test @TestMetadata("kt2892.kt") public void testKt2892() throws Exception { runTest("compiler/testData/codegen/box/properties/kt2892.kt"); } + @Test @TestMetadata("kt3118.kt") public void testKt3118() throws Exception { runTest("compiler/testData/codegen/box/properties/kt3118.kt"); } + @Test @TestMetadata("kt3524.kt") public void testKt3524() throws Exception { runTest("compiler/testData/codegen/box/properties/kt3524.kt"); } + @Test @TestMetadata("kt3551.kt") public void testKt3551() throws Exception { runTest("compiler/testData/codegen/box/properties/kt3551.kt"); } + @Test @TestMetadata("kt3556.kt") public void testKt3556() throws Exception { runTest("compiler/testData/codegen/box/properties/kt3556.kt"); } + @Test @TestMetadata("kt3930.kt") public void testKt3930() throws Exception { runTest("compiler/testData/codegen/box/properties/kt3930.kt"); } + @Test @TestMetadata("kt4140.kt") public void testKt4140() throws Exception { runTest("compiler/testData/codegen/box/properties/kt4140.kt"); } + @Test @TestMetadata("kt4252.kt") public void testKt4252() throws Exception { runTest("compiler/testData/codegen/box/properties/kt4252.kt"); } + @Test @TestMetadata("kt4252_2.kt") public void testKt4252_2() throws Exception { runTest("compiler/testData/codegen/box/properties/kt4252_2.kt"); } + @Test @TestMetadata("kt4340.kt") public void testKt4340() throws Exception { runTest("compiler/testData/codegen/box/properties/kt4340.kt"); } + @Test @TestMetadata("kt4373.kt") public void testKt4373() throws Exception { runTest("compiler/testData/codegen/box/properties/kt4373.kt"); } + @Test @TestMetadata("kt4383.kt") public void testKt4383() throws Exception { runTest("compiler/testData/codegen/box/properties/kt4383.kt"); } + @Test @TestMetadata("kt49203_lateinit.kt") public void testKt49203_lateinit() throws Exception { runTest("compiler/testData/codegen/box/properties/kt49203_lateinit.kt"); } + @Test @TestMetadata("kt49203_var.kt") public void testKt49203_var() throws Exception { runTest("compiler/testData/codegen/box/properties/kt49203_var.kt"); } + @Test @TestMetadata("kt613.kt") public void testKt613() throws Exception { runTest("compiler/testData/codegen/box/properties/kt613.kt"); } + @Test @TestMetadata("kt8928.kt") public void testKt8928() throws Exception { runTest("compiler/testData/codegen/box/properties/kt8928.kt"); } + @Test @TestMetadata("kt9603.kt") public void testKt9603() throws Exception { runTest("compiler/testData/codegen/box/properties/kt9603.kt"); } + @Test @TestMetadata("lazyInitialization.kt") public void testLazyInitialization() throws Exception { runTest("compiler/testData/codegen/box/properties/lazyInitialization.kt"); } + @Test @TestMetadata("lazyInitializationCyclicImports.kt") public void testLazyInitializationCyclicImports() throws Exception { runTest("compiler/testData/codegen/box/properties/lazyInitializationCyclicImports.kt"); } + @Test @TestMetadata("lazyInitializationMultiModule.kt") public void testLazyInitializationMultiModule() throws Exception { runTest("compiler/testData/codegen/box/properties/lazyInitializationMultiModule.kt"); } + @Test @TestMetadata("lazyInitializationOrder.kt") public void testLazyInitializationOrder() throws Exception { runTest("compiler/testData/codegen/box/properties/lazyInitializationOrder.kt"); } + @Test @TestMetadata("lazyInitializationSplitPerModule.kt") public void testLazyInitializationSplitPerModule() throws Exception { runTest("compiler/testData/codegen/box/properties/lazyInitializationSplitPerModule.kt"); } + @Test @TestMetadata("primitiveOverrideDefaultAccessor.kt") public void testPrimitiveOverrideDefaultAccessor() throws Exception { runTest("compiler/testData/codegen/box/properties/primitiveOverrideDefaultAccessor.kt"); } + @Test @TestMetadata("primitiveOverrideDelegateAccessor.kt") public void testPrimitiveOverrideDelegateAccessor() throws Exception { runTest("compiler/testData/codegen/box/properties/primitiveOverrideDelegateAccessor.kt"); } + @Test @TestMetadata("privateAccessorOfOverriddenProperty.kt") public void testPrivateAccessorOfOverriddenProperty() throws Exception { runTest("compiler/testData/codegen/box/properties/privateAccessorOfOverriddenProperty.kt"); } + @Test @TestMetadata("privatePropertyInConstructor.kt") public void testPrivatePropertyInConstructor() throws Exception { runTest("compiler/testData/codegen/box/properties/privatePropertyInConstructor.kt"); } + @Test @TestMetadata("privatePropertyWithoutBackingField.kt") public void testPrivatePropertyWithoutBackingField() throws Exception { runTest("compiler/testData/codegen/box/properties/privatePropertyWithoutBackingField.kt"); } + @Test @TestMetadata("twoAnnotatedExtensionPropertiesWithoutBackingFields.kt") public void testTwoAnnotatedExtensionPropertiesWithoutBackingFields() throws Exception { runTest("compiler/testData/codegen/box/properties/twoAnnotatedExtensionPropertiesWithoutBackingFields.kt"); } + @Test @TestMetadata("typeInferredFromGetter.kt") public void testTypeInferredFromGetter() throws Exception { runTest("compiler/testData/codegen/box/properties/typeInferredFromGetter.kt"); } + @Test @TestMetadata("unreachableUninitializedProperty.kt") public void testUnreachableUninitializedProperty() throws Exception { runTest("compiler/testData/codegen/box/properties/unreachableUninitializedProperty.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/properties/backingField") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class BackingField extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class BackingField { + @Test public void testAllFilesPresentInBackingField() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/backingField"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/properties/const") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Const extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Const { + @Test public void testAllFilesPresentInConst() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/const"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("anotherFile.kt") public void testAnotherFile() throws Exception { runTest("compiler/testData/codegen/box/properties/const/anotherFile.kt"); } + @Test @TestMetadata("constPropertyAccessor.kt") public void testConstPropertyAccessor() throws Exception { runTest("compiler/testData/codegen/box/properties/const/constPropertyAccessor.kt"); } + @Test @TestMetadata("intermoduleInlineConst.kt") public void testIntermoduleInlineConst() throws Exception { runTest("compiler/testData/codegen/box/properties/const/intermoduleInlineConst.kt"); } + @Test @TestMetadata("kt52970.kt") public void testKt52970() throws Exception { runTest("compiler/testData/codegen/box/properties/const/kt52970.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/properties/lateinit") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Lateinit extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Lateinit { + @Test @TestMetadata("accessor.kt") public void testAccessor() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/accessor.kt"); } + @Test @TestMetadata("accessorException.kt") public void testAccessorException() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/accessorException.kt"); } + @Test @TestMetadata("accessorExceptionPublic.kt") public void testAccessorExceptionPublic() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/accessorExceptionPublic.kt"); } + @Test public void testAllFilesPresentInLateinit() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("exceptionField.kt") public void testExceptionField() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/exceptionField.kt"); } + @Test @TestMetadata("exceptionGetter.kt") public void testExceptionGetter() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/exceptionGetter.kt"); } + @Test @TestMetadata("kt30548.kt") public void testKt30548() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/kt30548.kt"); } + @Test @TestMetadata("localClass.kt") public void testLocalClass() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/localClass.kt"); } + @Test @TestMetadata("nameClash.kt") public void testNameClash() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/nameClash.kt"); } + @Test @TestMetadata("override.kt") public void testOverride() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/override.kt"); } + @Test @TestMetadata("overrideException.kt") public void testOverrideException() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/overrideException.kt"); } + @Test @TestMetadata("privateSetter.kt") public void testPrivateSetter() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/privateSetter.kt"); } + @Test @TestMetadata("privateSetterFromLambda.kt") public void testPrivateSetterFromLambda() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/privateSetterFromLambda.kt"); } + @Test @TestMetadata("privateSetterViaSubclass.kt") public void testPrivateSetterViaSubclass() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/privateSetterViaSubclass.kt"); } + @Test @TestMetadata("privateVarInCompanion.kt") public void testPrivateVarInCompanion() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/privateVarInCompanion.kt"); } + @Test @TestMetadata("simpleVar.kt") public void testSimpleVar() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/simpleVar.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class IsInitializedAndDeinitialize extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class IsInitializedAndDeinitialize { + @Test public void testAllFilesPresentInIsInitializedAndDeinitialize() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("companionObjectField.kt") public void testCompanionObjectField() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize/companionObjectField.kt"); } + @Test @TestMetadata("emptyLhs.kt") public void testEmptyLhs() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize/emptyLhs.kt"); } + @Test @TestMetadata("innerSubclass.kt") public void testInnerSubclass() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize/innerSubclass.kt"); } + @Test @TestMetadata("isInitializedMultiFile.kt") public void testIsInitializedMultiFile() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize/isInitializedMultiFile.kt"); } + @Test @TestMetadata("nonInlineLambda.kt") public void testNonInlineLambda() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize/nonInlineLambda.kt"); } + @Test @TestMetadata("propertyImportedFromObject.kt") public void testPropertyImportedFromObject() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize/propertyImportedFromObject.kt"); } + @Test @TestMetadata("sideEffects.kt") public void testSideEffects() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize/sideEffects.kt"); } + @Test @TestMetadata("topLevelProperty.kt") public void testTopLevelProperty() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize/topLevelProperty.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/properties/lateinit/local") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Local extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Local { + @Test public void testAllFilesPresentInLocal() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/local"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("capturedLocalLateinit.kt") public void testCapturedLocalLateinit() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/local/capturedLocalLateinit.kt"); } + @Test @TestMetadata("kt23260.kt") public void testKt23260() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/local/kt23260.kt"); } + @Test @TestMetadata("localLateinit.kt") public void testLocalLateinit() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/local/localLateinit.kt"); } + @Test @TestMetadata("uninitializedCapturedMemberAccess.kt") public void testUninitializedCapturedMemberAccess() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/local/uninitializedCapturedMemberAccess.kt"); } + @Test @TestMetadata("uninitializedCapturedRead.kt") public void testUninitializedCapturedRead() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/local/uninitializedCapturedRead.kt"); } + @Test @TestMetadata("uninitializedMemberAccess.kt") public void testUninitializedMemberAccess() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/local/uninitializedMemberAccess.kt"); } + @Test @TestMetadata("uninitializedRead.kt") public void testUninitializedRead() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/local/uninitializedRead.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/properties/lateinit/topLevel") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TopLevel extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class TopLevel { + @Test @TestMetadata("accessorException.kt") public void testAccessorException() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/topLevel/accessorException.kt"); } + @Test @TestMetadata("accessorForTopLevelLateinit.kt") public void testAccessorForTopLevelLateinit() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/topLevel/accessorForTopLevelLateinit.kt"); } + @Test public void testAllFilesPresentInTopLevel() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/topLevel"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("topLevelLateinit.kt") public void testTopLevelLateinit() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/topLevel/topLevelLateinit.kt"); } + @Test @TestMetadata("uninitializedMemberAccess.kt") public void testUninitializedMemberAccess() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/topLevel/uninitializedMemberAccess.kt"); } + @Test @TestMetadata("uninitializedRead.kt") public void testUninitializedRead() throws Exception { runTest("compiler/testData/codegen/box/properties/lateinit/topLevel/uninitializedRead.kt"); @@ -23515,570 +26370,662 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/publishedApi") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class PublishedApi extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class PublishedApi { + @Test public void testAllFilesPresentInPublishedApi() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/publishedApi"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("inlineFromFriendModule.kt") public void testInlineFromFriendModule() throws Exception { runTest("compiler/testData/codegen/box/publishedApi/inlineFromFriendModule.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/publishedApi/simple.kt"); } + @Test @TestMetadata("topLevel.kt") public void testTopLevel() throws Exception { runTest("compiler/testData/codegen/box/publishedApi/topLevel.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Ranges extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Ranges { + @Test public void testAllFilesPresentInRanges() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("capturedLoopVar.kt") public void testCapturedLoopVar() throws Exception { runTest("compiler/testData/codegen/box/ranges/capturedLoopVar.kt"); } + @Test @TestMetadata("forByteProgressionWithIntIncrement.kt") public void testForByteProgressionWithIntIncrement() throws Exception { runTest("compiler/testData/codegen/box/ranges/forByteProgressionWithIntIncrement.kt"); } + @Test @TestMetadata("forInCharSequenceLengthDecreasedInLoopBody.kt") public void testForInCharSequenceLengthDecreasedInLoopBody() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInCharSequenceLengthDecreasedInLoopBody.kt"); } + @Test @TestMetadata("forInCharSequenceLengthIncreasedInLoopBody.kt") public void testForInCharSequenceLengthIncreasedInLoopBody() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInCharSequenceLengthIncreasedInLoopBody.kt"); } + @Test @TestMetadata("forInCharSequenceWithCustomIterator.kt") public void testForInCharSequenceWithCustomIterator() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInCharSequenceWithCustomIterator.kt"); } + @Test @TestMetadata("forInCharSequenceWithMultipleGetFunctions.kt") public void testForInCharSequenceWithMultipleGetFunctions() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInCharSequenceWithMultipleGetFunctions.kt"); } + @Test @TestMetadata("forInCustomCharSequence.kt") public void testForInCustomCharSequence() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInCustomCharSequence.kt"); } + @Test @TestMetadata("forInCustomIterable.kt") public void testForInCustomIterable() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInCustomIterable.kt"); } + @Test @TestMetadata("forInDoubleRangeWithCustomIterator.kt") public void testForInDoubleRangeWithCustomIterator() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInDoubleRangeWithCustomIterator.kt"); } + @Test @TestMetadata("forInFloatRangeWithCustomIterator.kt") public void testForInFloatRangeWithCustomIterator() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInFloatRangeWithCustomIterator.kt"); } + @Test @TestMetadata("forInIntRangeToConstWithBreak.kt") public void testForInIntRangeToConstWithBreak() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIntRangeToConstWithBreak.kt"); } + @Test @TestMetadata("forInIntRangeToConstWithContinue.kt") public void testForInIntRangeToConstWithContinue() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIntRangeToConstWithContinue.kt"); } + @Test @TestMetadata("forInRangeLiteralWithMixedTypeBounds.kt") public void testForInRangeLiteralWithMixedTypeBounds() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInRangeLiteralWithMixedTypeBounds.kt"); } + @Test @TestMetadata("forInRangeWithImplicitReceiver.kt") public void testForInRangeWithImplicitReceiver() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInRangeWithImplicitReceiver.kt"); } + @Test @TestMetadata("forInStringVarUpdatedInLoopBody.kt") public void testForInStringVarUpdatedInLoopBody() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInStringVarUpdatedInLoopBody.kt"); } + @Test @TestMetadata("forIntRange.kt") public void testForIntRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/forIntRange.kt"); } + @Test @TestMetadata("forNullableIntInRangeWithImplicitReceiver.kt") public void testForNullableIntInRangeWithImplicitReceiver() throws Exception { runTest("compiler/testData/codegen/box/ranges/forNullableIntInRangeWithImplicitReceiver.kt"); } + @Test @TestMetadata("kt37370.kt") public void testKt37370() throws Exception { runTest("compiler/testData/codegen/box/ranges/kt37370.kt"); } + @Test @TestMetadata("kt37370a.kt") public void testKt37370a() throws Exception { runTest("compiler/testData/codegen/box/ranges/kt37370a.kt"); } + @Test @TestMetadata("kt47492.kt") public void testKt47492() throws Exception { runTest("compiler/testData/codegen/box/ranges/kt47492.kt"); } + @Test @TestMetadata("kt47492a.kt") public void testKt47492a() throws Exception { runTest("compiler/testData/codegen/box/ranges/kt47492a.kt"); } + @Test @TestMetadata("kt47492b.kt") public void testKt47492b() throws Exception { runTest("compiler/testData/codegen/box/ranges/kt47492b.kt"); } + @Test @TestMetadata("multiAssignmentIterationOverIntRange.kt") public void testMultiAssignmentIterationOverIntRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/multiAssignmentIterationOverIntRange.kt"); } + @Test @TestMetadata("safeCallRangeTo.kt") public void testSafeCallRangeTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/safeCallRangeTo.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/contains") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Contains extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Contains { + @Test public void testAllFilesPresentInContains() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("charInCharRangeWithPossibleOverflow.kt") public void testCharInCharRangeWithPossibleOverflow() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/charInCharRangeWithPossibleOverflow.kt"); } + @Test @TestMetadata("comparisonWithRangeBoundEliminated.kt") public void testComparisonWithRangeBoundEliminated() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/comparisonWithRangeBoundEliminated.kt"); } + @Test @TestMetadata("evaluationOrderForCollection.kt") public void testEvaluationOrderForCollection() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/evaluationOrderForCollection.kt"); } + @Test @TestMetadata("evaluationOrderForComparableRange.kt") public void testEvaluationOrderForComparableRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/evaluationOrderForComparableRange.kt"); } + @Test @TestMetadata("evaluationOrderForDownTo.kt") public void testEvaluationOrderForDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/evaluationOrderForDownTo.kt"); } + @Test @TestMetadata("evaluationOrderForDownToReversed.kt") public void testEvaluationOrderForDownToReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/evaluationOrderForDownToReversed.kt"); } + @Test @TestMetadata("evaluationOrderForNullableArgument.kt") public void testEvaluationOrderForNullableArgument() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/evaluationOrderForNullableArgument.kt"); } + @Test @TestMetadata("evaluationOrderForRangeLiteral.kt") public void testEvaluationOrderForRangeLiteral() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/evaluationOrderForRangeLiteral.kt"); } + @Test @TestMetadata("evaluationOrderForRangeLiteralReversed.kt") public void testEvaluationOrderForRangeLiteralReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/evaluationOrderForRangeLiteralReversed.kt"); } + @Test @TestMetadata("evaluationOrderForUntil.kt") public void testEvaluationOrderForUntil() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/evaluationOrderForUntil.kt"); } + @Test @TestMetadata("evaluationOrderForUntilReversed.kt") public void testEvaluationOrderForUntilReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/evaluationOrderForUntilReversed.kt"); } + @Test @TestMetadata("genericCharInRangeLiteral.kt") public void testGenericCharInRangeLiteral() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/genericCharInRangeLiteral.kt"); } + @Test @TestMetadata("inArray.kt") public void testInArray() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/inArray.kt"); } + @Test @TestMetadata("inCharSequence.kt") public void testInCharSequence() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/inCharSequence.kt"); } + @Test @TestMetadata("inComparableRange.kt") public void testInComparableRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/inComparableRange.kt"); } + @Test @TestMetadata("inCustomObjectRange.kt") public void testInCustomObjectRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/inCustomObjectRange.kt"); } + @Test @TestMetadata("inDoubleRangeLiteralVsComparableRangeLiteral.kt") public void testInDoubleRangeLiteralVsComparableRangeLiteral() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/inDoubleRangeLiteralVsComparableRangeLiteral.kt"); } + @Test @TestMetadata("inExtensionRange.kt") public void testInExtensionRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/inExtensionRange.kt"); } + @Test @TestMetadata("inFloatingPointRangeWithNaNBound.kt") public void testInFloatingPointRangeWithNaNBound() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/inFloatingPointRangeWithNaNBound.kt"); } + @Test @TestMetadata("inIntRange.kt") public void testInIntRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/inIntRange.kt"); } + @Test @TestMetadata("inIterable.kt") public void testInIterable() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/inIterable.kt"); } + @Test @TestMetadata("inNonMatchingRange.kt") public void testInNonMatchingRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/inNonMatchingRange.kt"); } + @Test @TestMetadata("inOptimizableDoubleRange.kt") public void testInOptimizableDoubleRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/inOptimizableDoubleRange.kt"); } + @Test @TestMetadata("inOptimizableFloatRange.kt") public void testInOptimizableFloatRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/inOptimizableFloatRange.kt"); } + @Test @TestMetadata("inOptimizableIntRange.kt") public void testInOptimizableIntRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/inOptimizableIntRange.kt"); } + @Test @TestMetadata("inOptimizableLongRange.kt") public void testInOptimizableLongRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/inOptimizableLongRange.kt"); } + @Test @TestMetadata("inPrimitiveProgression.kt") public void testInPrimitiveProgression() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/inPrimitiveProgression.kt"); } + @Test @TestMetadata("inPrimitiveRange.kt") public void testInPrimitiveRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/inPrimitiveRange.kt"); } + @Test @TestMetadata("inRangeLiteralComposition.kt") public void testInRangeLiteralComposition() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/inRangeLiteralComposition.kt"); } + @Test @TestMetadata("inRangeWithCustomContains.kt") public void testInRangeWithCustomContains() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/inRangeWithCustomContains.kt"); } + @Test @TestMetadata("inRangeWithImplicitReceiver.kt") public void testInRangeWithImplicitReceiver() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/inRangeWithImplicitReceiver.kt"); } + @Test @TestMetadata("inRangeWithNonmatchingArguments.kt") public void testInRangeWithNonmatchingArguments() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/inRangeWithNonmatchingArguments.kt"); } + @Test @TestMetadata("inRangeWithSmartCast.kt") public void testInRangeWithSmartCast() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/inRangeWithSmartCast.kt"); } + @Test @TestMetadata("inUntil.kt") public void testInUntil() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/inUntil.kt"); } + @Test @TestMetadata("inUntilMaxValue.kt") public void testInUntilMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/inUntilMaxValue.kt"); } + @Test @TestMetadata("inUntilMinValue.kt") public void testInUntilMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/inUntilMinValue.kt"); } + @Test @TestMetadata("inUntilMinValueNonConst.kt") public void testInUntilMinValueNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/inUntilMinValueNonConst.kt"); } + @Test @TestMetadata("intInByteRangeWithPossibleOverflow.kt") public void testIntInByteRangeWithPossibleOverflow() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/intInByteRangeWithPossibleOverflow.kt"); } + @Test @TestMetadata("intInIntRangeWithPossibleOverflow.kt") public void testIntInIntRangeWithPossibleOverflow() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/intInIntRangeWithPossibleOverflow.kt"); } + @Test @TestMetadata("intInShortRangeWithPossibleOverflow.kt") public void testIntInShortRangeWithPossibleOverflow() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/intInShortRangeWithPossibleOverflow.kt"); } + @Test @TestMetadata("kt20106.kt") public void testKt20106() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/kt20106.kt"); } + @Test @TestMetadata("longInLongRangeWithPossibleOverflow.kt") public void testLongInLongRangeWithPossibleOverflow() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/longInLongRangeWithPossibleOverflow.kt"); } + @Test @TestMetadata("nullableInPrimitiveRange.kt") public void testNullableInPrimitiveRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/nullableInPrimitiveRange.kt"); } + @Test @TestMetadata("rangeContainsString.kt") public void testRangeContainsString() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/rangeContainsString.kt"); } + @Test @TestMetadata("smartCastOnBothEnds.kt") public void testSmartCastOnBothEnds() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/smartCastOnBothEnds.kt"); } + @Test @TestMetadata("uintInUByteRangeWithPossibleOverflow.kt") public void testUintInUByteRangeWithPossibleOverflow() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/uintInUByteRangeWithPossibleOverflow.kt"); } + @Test @TestMetadata("uintInUIntRangeWithPossibleOverflow.kt") public void testUintInUIntRangeWithPossibleOverflow() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/uintInUIntRangeWithPossibleOverflow.kt"); } + @Test @TestMetadata("uintInUShortRangeWithPossibleOverflow.kt") public void testUintInUShortRangeWithPossibleOverflow() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/uintInUShortRangeWithPossibleOverflow.kt"); } + @Test @TestMetadata("ulongInULongRangeWithPossibleOverflow.kt") public void testUlongInULongRangeWithPossibleOverflow() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/ulongInULongRangeWithPossibleOverflow.kt"); } + @Test @TestMetadata("userDefinedContainsExtension.kt") public void testUserDefinedContainsExtension() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/userDefinedContainsExtension.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/contains/generated") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Generated extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Generated { + @Test public void testAllFilesPresentInGenerated() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains/generated"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("arrayIndices.kt") public void testArrayIndices() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/arrayIndices.kt"); } + @Test @TestMetadata("charDownTo.kt") public void testCharDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/charDownTo.kt"); } + @Test @TestMetadata("charRangeTo.kt") public void testCharRangeTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/charRangeTo.kt"); } + @Test @TestMetadata("charRangeUntil.kt") public void testCharRangeUntil() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/charRangeUntil.kt"); } + @Test @TestMetadata("charSequenceIndices.kt") public void testCharSequenceIndices() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/charSequenceIndices.kt"); } + @Test @TestMetadata("charUntil.kt") public void testCharUntil() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/charUntil.kt"); } + @Test @TestMetadata("collectionIndices.kt") public void testCollectionIndices() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/collectionIndices.kt"); } + @Test @TestMetadata("doubleRangeTo.kt") public void testDoubleRangeTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/doubleRangeTo.kt"); } + @Test @TestMetadata("doubleRangeUntil.kt") public void testDoubleRangeUntil() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/doubleRangeUntil.kt"); } + @Test @TestMetadata("floatRangeTo.kt") public void testFloatRangeTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/floatRangeTo.kt"); } + @Test @TestMetadata("floatRangeUntil.kt") public void testFloatRangeUntil() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/floatRangeUntil.kt"); } + @Test @TestMetadata("intDownTo.kt") public void testIntDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/intDownTo.kt"); } + @Test @TestMetadata("intRangeTo.kt") public void testIntRangeTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/intRangeTo.kt"); } + @Test @TestMetadata("intRangeUntil.kt") public void testIntRangeUntil() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/intRangeUntil.kt"); } + @Test @TestMetadata("intUntil.kt") public void testIntUntil() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/intUntil.kt"); } + @Test @TestMetadata("longDownTo.kt") public void testLongDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/longDownTo.kt"); } + @Test @TestMetadata("longRangeTo.kt") public void testLongRangeTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/longRangeTo.kt"); } + @Test @TestMetadata("longRangeUntil.kt") public void testLongRangeUntil() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/longRangeUntil.kt"); } + @Test @TestMetadata("longUntil.kt") public void testLongUntil() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/longUntil.kt"); } + @Test @TestMetadata("uintDownTo.kt") public void testUintDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/uintDownTo.kt"); } + @Test @TestMetadata("uintRangeTo.kt") public void testUintRangeTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/uintRangeTo.kt"); } + @Test @TestMetadata("uintRangeUntil.kt") public void testUintRangeUntil() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/uintRangeUntil.kt"); } + @Test @TestMetadata("uintUntil.kt") public void testUintUntil() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/uintUntil.kt"); } + @Test @TestMetadata("ulongDownTo.kt") public void testUlongDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/ulongDownTo.kt"); } + @Test @TestMetadata("ulongRangeTo.kt") public void testUlongRangeTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/ulongRangeTo.kt"); } + @Test @TestMetadata("ulongRangeUntil.kt") public void testUlongRangeUntil() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/ulongRangeUntil.kt"); } + @Test @TestMetadata("ulongUntil.kt") public void testUlongUntil() throws Exception { runTest("compiler/testData/codegen/box/ranges/contains/generated/ulongUntil.kt"); @@ -24086,228 +27033,246 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/evaluationOrder") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class EvaluationOrder extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class EvaluationOrder { + @Test public void testAllFilesPresentInEvaluationOrder() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("forInDownTo.kt") public void testForInDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/forInDownTo.kt"); } + @Test @TestMetadata("forInDownToReversed.kt") public void testForInDownToReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/forInDownToReversed.kt"); } + @Test @TestMetadata("forInDownToReversedReversed.kt") public void testForInDownToReversedReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/forInDownToReversedReversed.kt"); } + @Test @TestMetadata("forInRangeLiteral.kt") public void testForInRangeLiteral() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/forInRangeLiteral.kt"); } + @Test @TestMetadata("forInRangeLiteralReversed.kt") public void testForInRangeLiteralReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/forInRangeLiteralReversed.kt"); } + @Test @TestMetadata("forInRangeLiteralReversedReversed.kt") public void testForInRangeLiteralReversedReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/forInRangeLiteralReversedReversed.kt"); } + @Test @TestMetadata("forInUntil.kt") public void testForInUntil() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/forInUntil.kt"); } + @Test @TestMetadata("forInUntilReversed.kt") public void testForInUntilReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/forInUntilReversed.kt"); } + @Test @TestMetadata("forInUntilReversedReversed.kt") public void testForInUntilReversedReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/forInUntilReversedReversed.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/evaluationOrder/stepped") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Stepped extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Stepped { + @Test public void testAllFilesPresentInStepped() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ForInDownTo extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ForInDownTo { + @Test public void testAllFilesPresentInForInDownTo() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("forInDownToReversedStep.kt") public void testForInDownToReversedStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo/forInDownToReversedStep.kt"); } + @Test @TestMetadata("forInDownToReversedStepReversed.kt") public void testForInDownToReversedStepReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo/forInDownToReversedStepReversed.kt"); } + @Test @TestMetadata("forInDownToReversedStepReversedStep.kt") public void testForInDownToReversedStepReversedStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo/forInDownToReversedStepReversedStep.kt"); } + @Test @TestMetadata("forInDownToStep.kt") public void testForInDownToStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo/forInDownToStep.kt"); } + @Test @TestMetadata("forInDownToStepReversed.kt") public void testForInDownToStepReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo/forInDownToStepReversed.kt"); } + @Test @TestMetadata("forInDownToStepReversedStep.kt") public void testForInDownToStepReversedStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo/forInDownToStepReversedStep.kt"); } + @Test @TestMetadata("forInDownToStepReversedStepReversed.kt") public void testForInDownToStepReversedStepReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo/forInDownToStepReversedStepReversed.kt"); } + @Test @TestMetadata("forInDownToStepStep.kt") public void testForInDownToStepStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo/forInDownToStepStep.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ForInRangeLiteral extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ForInRangeLiteral { + @Test public void testAllFilesPresentInForInRangeLiteral() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("forInRangeLiteralReversedStep.kt") public void testForInRangeLiteralReversedStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral/forInRangeLiteralReversedStep.kt"); } + @Test @TestMetadata("forInRangeLiteralReversedStepReversed.kt") public void testForInRangeLiteralReversedStepReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral/forInRangeLiteralReversedStepReversed.kt"); } + @Test @TestMetadata("forInRangeLiteralReversedStepReversedStep.kt") public void testForInRangeLiteralReversedStepReversedStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral/forInRangeLiteralReversedStepReversedStep.kt"); } + @Test @TestMetadata("forInRangeLiteralStep.kt") public void testForInRangeLiteralStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral/forInRangeLiteralStep.kt"); } + @Test @TestMetadata("forInRangeLiteralStepReversed.kt") public void testForInRangeLiteralStepReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral/forInRangeLiteralStepReversed.kt"); } + @Test @TestMetadata("forInRangeLiteralStepReversedStep.kt") public void testForInRangeLiteralStepReversedStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral/forInRangeLiteralStepReversedStep.kt"); } + @Test @TestMetadata("forInRangeLiteralStepReversedStepReversed.kt") public void testForInRangeLiteralStepReversedStepReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral/forInRangeLiteralStepReversedStepReversed.kt"); } + @Test @TestMetadata("forInRangeLiteralStepStep.kt") public void testForInRangeLiteralStepStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral/forInRangeLiteralStepStep.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ForInUntil extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ForInUntil { + @Test public void testAllFilesPresentInForInUntil() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("forInUntilReversedStep.kt") public void testForInUntilReversedStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil/forInUntilReversedStep.kt"); } + @Test @TestMetadata("forInUntilReversedStepReversed.kt") public void testForInUntilReversedStepReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil/forInUntilReversedStepReversed.kt"); } + @Test @TestMetadata("forInUntilReversedStepReversedStep.kt") public void testForInUntilReversedStepReversedStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil/forInUntilReversedStepReversedStep.kt"); } + @Test @TestMetadata("forInUntilStep.kt") public void testForInUntilStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil/forInUntilStep.kt"); } + @Test @TestMetadata("forInUntilStepReversed.kt") public void testForInUntilStepReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil/forInUntilStepReversed.kt"); } + @Test @TestMetadata("forInUntilStepReversedStep.kt") public void testForInUntilStepReversedStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil/forInUntilStepReversedStep.kt"); } + @Test @TestMetadata("forInUntilStepReversedStepReversed.kt") public void testForInUntilStepReversedStepReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil/forInUntilStepReversedStepReversed.kt"); } + @Test @TestMetadata("forInUntilStepStep.kt") public void testForInUntilStepStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil/forInUntilStepStep.kt"); @@ -24316,1140 +27281,1279 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/expression") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Expression extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Expression { + @Test public void testAllFilesPresentInExpression() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/expression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("emptyDownto.kt") public void testEmptyDownto() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/emptyDownto.kt"); } + @Test @TestMetadata("emptyRange.kt") public void testEmptyRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/emptyRange.kt"); } + @Test @TestMetadata("inexactDownToMinValue.kt") public void testInexactDownToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/inexactDownToMinValue.kt"); } + @Test @TestMetadata("inexactSteppedDownTo.kt") public void testInexactSteppedDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/inexactSteppedDownTo.kt"); } + @Test @TestMetadata("inexactSteppedRange.kt") public void testInexactSteppedRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/inexactSteppedRange.kt"); } + @Test @TestMetadata("inexactToMaxValue.kt") public void testInexactToMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/inexactToMaxValue.kt"); } + @Test @TestMetadata("maxValueMinusTwoToMaxValue.kt") public void testMaxValueMinusTwoToMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/maxValueMinusTwoToMaxValue.kt"); } + @Test @TestMetadata("maxValueToMaxValue.kt") public void testMaxValueToMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/maxValueToMaxValue.kt"); } + @Test @TestMetadata("maxValueToMinValue.kt") public void testMaxValueToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/maxValueToMinValue.kt"); } + @Test @TestMetadata("oneElementDownTo.kt") public void testOneElementDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/oneElementDownTo.kt"); } + @Test @TestMetadata("oneElementRange.kt") public void testOneElementRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/oneElementRange.kt"); } + @Test @TestMetadata("openRange.kt") public void testOpenRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/openRange.kt"); } + @Test @TestMetadata("openRangeUntil.kt") public void testOpenRangeUntil() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/openRangeUntil.kt"); } + @Test @TestMetadata("overflowZeroDownToMaxValue.kt") public void testOverflowZeroDownToMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/overflowZeroDownToMaxValue.kt"); } + @Test @TestMetadata("overflowZeroToMinValue.kt") public void testOverflowZeroToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/overflowZeroToMinValue.kt"); } + @Test @TestMetadata("progressionDownToMinValue.kt") public void testProgressionDownToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/progressionDownToMinValue.kt"); } + @Test @TestMetadata("progressionMaxValueMinusTwoToMaxValue.kt") public void testProgressionMaxValueMinusTwoToMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/progressionMaxValueMinusTwoToMaxValue.kt"); } + @Test @TestMetadata("progressionMaxValueToMaxValue.kt") public void testProgressionMaxValueToMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/progressionMaxValueToMaxValue.kt"); } + @Test @TestMetadata("progressionMaxValueToMinValue.kt") public void testProgressionMaxValueToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/progressionMaxValueToMinValue.kt"); } + @Test @TestMetadata("progressionMinValueToMinValue.kt") public void testProgressionMinValueToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/progressionMinValueToMinValue.kt"); } + @Test @TestMetadata("reversedBackSequence.kt") public void testReversedBackSequence() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/reversedBackSequence.kt"); } + @Test @TestMetadata("reversedEmptyBackSequence.kt") public void testReversedEmptyBackSequence() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/reversedEmptyBackSequence.kt"); } + @Test @TestMetadata("reversedEmptyRange.kt") public void testReversedEmptyRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/reversedEmptyRange.kt"); } + @Test @TestMetadata("reversedInexactSteppedDownTo.kt") public void testReversedInexactSteppedDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/reversedInexactSteppedDownTo.kt"); } + @Test @TestMetadata("reversedRange.kt") public void testReversedRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/reversedRange.kt"); } + @Test @TestMetadata("reversedSimpleSteppedRange.kt") public void testReversedSimpleSteppedRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/reversedSimpleSteppedRange.kt"); } + @Test @TestMetadata("simpleDownTo.kt") public void testSimpleDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/simpleDownTo.kt"); } + @Test @TestMetadata("simpleRange.kt") public void testSimpleRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/simpleRange.kt"); } + @Test @TestMetadata("simpleRangeWithNonConstantEnds.kt") public void testSimpleRangeWithNonConstantEnds() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/simpleRangeWithNonConstantEnds.kt"); } + @Test @TestMetadata("simpleSteppedDownTo.kt") public void testSimpleSteppedDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/simpleSteppedDownTo.kt"); } + @Test @TestMetadata("simpleSteppedRange.kt") public void testSimpleSteppedRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/expression/simpleSteppedRange.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/forInDownTo") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ForInDownTo extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ForInDownTo { + @Test public void testAllFilesPresentInForInDownTo() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInDownTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("forInDownToWithPossibleUnderflow.kt") public void testForInDownToWithPossibleUnderflow() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInDownTo/forInDownToWithPossibleUnderflow.kt"); } + @Test @TestMetadata("forInSumDownToSum.kt") public void testForInSumDownToSum() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInDownTo/forInSumDownToSum.kt"); } + @Test @TestMetadata("forIntInDownTo.kt") public void testForIntInDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInDownTo/forIntInDownTo.kt"); } + @Test @TestMetadata("forIntInDownToWithNonConstBounds.kt") public void testForIntInDownToWithNonConstBounds() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInDownTo/forIntInDownToWithNonConstBounds.kt"); } + @Test @TestMetadata("forIntInNonOptimizedDownTo.kt") public void testForIntInNonOptimizedDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInDownTo/forIntInNonOptimizedDownTo.kt"); } + @Test @TestMetadata("forLongInDownTo.kt") public void testForLongInDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInDownTo/forLongInDownTo.kt"); } + @Test @TestMetadata("forNullableIntInDownTo.kt") public void testForNullableIntInDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInDownTo/forNullableIntInDownTo.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/forInIndices") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ForInIndices extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ForInIndices { + @Test public void testAllFilesPresentInForInIndices() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInIndices"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("forInArrayListIndices.kt") public void testForInArrayListIndices() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIndices/forInArrayListIndices.kt"); } + @Test @TestMetadata("forInCharSequenceIndices.kt") public void testForInCharSequenceIndices() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIndices/forInCharSequenceIndices.kt"); } + @Test @TestMetadata("forInCharSequenceTypeParameterIndices.kt") public void testForInCharSequenceTypeParameterIndices() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIndices/forInCharSequenceTypeParameterIndices.kt"); } + @Test @TestMetadata("forInCollectionImplicitReceiverIndices.kt") public void testForInCollectionImplicitReceiverIndices() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIndices/forInCollectionImplicitReceiverIndices.kt"); } + @Test @TestMetadata("forInCollectionIndices.kt") public void testForInCollectionIndices() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIndices/forInCollectionIndices.kt"); } + @Test @TestMetadata("forInCollectionTypeParameterIndices.kt") public void testForInCollectionTypeParameterIndices() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIndices/forInCollectionTypeParameterIndices.kt"); } + @Test @TestMetadata("forInListIndices.kt") public void testForInListIndices() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIndices/forInListIndices.kt"); } + @Test @TestMetadata("forInListIndicesBreak.kt") public void testForInListIndicesBreak() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIndices/forInListIndicesBreak.kt"); } + @Test @TestMetadata("forInListIndicesContinue.kt") public void testForInListIndicesContinue() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIndices/forInListIndicesContinue.kt"); } + @Test @TestMetadata("forInNonOptimizedIndices.kt") public void testForInNonOptimizedIndices() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIndices/forInNonOptimizedIndices.kt"); } + @Test @TestMetadata("forInObjectArrayIndices.kt") public void testForInObjectArrayIndices() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIndices/forInObjectArrayIndices.kt"); } + @Test @TestMetadata("forInPrimitiveArrayIndices.kt") public void testForInPrimitiveArrayIndices() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIndices/forInPrimitiveArrayIndices.kt"); } + @Test @TestMetadata("forNullableIntInArrayIndices.kt") public void testForNullableIntInArrayIndices() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIndices/forNullableIntInArrayIndices.kt"); } + @Test @TestMetadata("forNullableIntInCollectionIndices.kt") public void testForNullableIntInCollectionIndices() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIndices/forNullableIntInCollectionIndices.kt"); } + @Test @TestMetadata("indexOfLast.kt") public void testIndexOfLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIndices/indexOfLast.kt"); } + @Test @TestMetadata("kt12983_forInGenericArrayIndices.kt") public void testKt12983_forInGenericArrayIndices() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIndices/kt12983_forInGenericArrayIndices.kt"); } + @Test @TestMetadata("kt12983_forInGenericCollectionIndices.kt") public void testKt12983_forInGenericCollectionIndices() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIndices/kt12983_forInGenericCollectionIndices.kt"); } + @Test @TestMetadata("kt12983_forInSpecificArrayIndices.kt") public void testKt12983_forInSpecificArrayIndices() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIndices/kt12983_forInSpecificArrayIndices.kt"); } + @Test @TestMetadata("kt12983_forInSpecificCollectionIndices.kt") public void testKt12983_forInSpecificCollectionIndices() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIndices/kt12983_forInSpecificCollectionIndices.kt"); } + @Test @TestMetadata("kt13241_Array.kt") public void testKt13241_Array() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIndices/kt13241_Array.kt"); } + @Test @TestMetadata("kt13241_CharSequence.kt") public void testKt13241_CharSequence() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIndices/kt13241_CharSequence.kt"); } + @Test @TestMetadata("kt13241_Collection.kt") public void testKt13241_Collection() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIndices/kt13241_Collection.kt"); } + @Test @TestMetadata("kt43159_ArrayUpperBound.kt") public void testKt43159_ArrayUpperBound() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIndices/kt43159_ArrayUpperBound.kt"); } + @Test @TestMetadata("kt43159_GenericArray.kt") public void testKt43159_GenericArray() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInIndices/kt43159_GenericArray.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/forInProgressionWithIndex") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ForInProgressionWithIndex extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ForInProgressionWithIndex { + @Test public void testAllFilesPresentInForInProgressionWithIndex() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInProgressionWithIndex"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("forInDownToWithIndex.kt") public void testForInDownToWithIndex() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInDownToWithIndex.kt"); } + @Test @TestMetadata("forInIndicesWithIndex.kt") public void testForInIndicesWithIndex() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInIndicesWithIndex.kt"); } + @Test @TestMetadata("forInRangeToWithIndex.kt") public void testForInRangeToWithIndex() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInRangeToWithIndex.kt"); } + @Test @TestMetadata("forInReversedStepWithIndex.kt") public void testForInReversedStepWithIndex() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInReversedStepWithIndex.kt"); } + @Test @TestMetadata("forInReversedWithIndex.kt") public void testForInReversedWithIndex() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInReversedWithIndex.kt"); } + @Test @TestMetadata("forInStepReversedWithIndex.kt") public void testForInStepReversedWithIndex() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInStepReversedWithIndex.kt"); } + @Test @TestMetadata("forInStepWithIndex.kt") public void testForInStepWithIndex() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInStepWithIndex.kt"); } + @Test @TestMetadata("forInUntilWithIndex.kt") public void testForInUntilWithIndex() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInUntilWithIndex.kt"); } + @Test @TestMetadata("forInWithIndexBreakAndContinue.kt") public void testForInWithIndexBreakAndContinue() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInWithIndexBreakAndContinue.kt"); } + @Test @TestMetadata("forInWithIndexNoIndexOrElementVar.kt") public void testForInWithIndexNoIndexOrElementVar() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInWithIndexNoIndexOrElementVar.kt"); } + @Test @TestMetadata("forInWithIndexNotDestructured.kt") public void testForInWithIndexNotDestructured() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInWithIndexNotDestructured.kt"); } + @Test @TestMetadata("forInWithIndexReversed.kt") public void testForInWithIndexReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInWithIndexReversed.kt"); } + @Test @TestMetadata("forInWithIndexWithDestructuringInLoop.kt") public void testForInWithIndexWithDestructuringInLoop() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInWithIndexWithDestructuringInLoop.kt"); } + @Test @TestMetadata("forInWithIndexWithIndex.kt") public void testForInWithIndexWithIndex() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInWithIndexWithIndex.kt"); } + @Test @TestMetadata("kt42909.kt") public void testKt42909() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/kt42909.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/forInReversed") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ForInReversed extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ForInReversed { + @Test public void testAllFilesPresentInForInReversed() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInReversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("forInReversedArrayIndices.kt") public void testForInReversedArrayIndices() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedArrayIndices.kt"); } + @Test @TestMetadata("forInReversedCharSequenceIndices.kt") public void testForInReversedCharSequenceIndices() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedCharSequenceIndices.kt"); } + @Test @TestMetadata("forInReversedCollectionIndices.kt") public void testForInReversedCollectionIndices() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedCollectionIndices.kt"); } + @Test @TestMetadata("forInReversedDownTo.kt") public void testForInReversedDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedDownTo.kt"); } + @Test @TestMetadata("forInReversedEmptyRange.kt") public void testForInReversedEmptyRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedEmptyRange.kt"); } + @Test @TestMetadata("forInReversedEmptyRangeLiteral.kt") public void testForInReversedEmptyRangeLiteral() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedEmptyRangeLiteral.kt"); } + @Test @TestMetadata("forInReversedEmptyRangeLiteralWithNonConstBounds.kt") public void testForInReversedEmptyRangeLiteralWithNonConstBounds() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedEmptyRangeLiteralWithNonConstBounds.kt"); } + @Test @TestMetadata("forInReversedRange.kt") public void testForInReversedRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedRange.kt"); } + @Test @TestMetadata("forInReversedRangeLiteral.kt") public void testForInReversedRangeLiteral() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedRangeLiteral.kt"); } + @Test @TestMetadata("forInReversedRangeLiteralWithNonConstBounds.kt") public void testForInReversedRangeLiteralWithNonConstBounds() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedRangeLiteralWithNonConstBounds.kt"); } + @Test @TestMetadata("forInReversedReversedArrayIndices.kt") public void testForInReversedReversedArrayIndices() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedReversedArrayIndices.kt"); } + @Test @TestMetadata("forInReversedReversedDownTo.kt") public void testForInReversedReversedDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedReversedDownTo.kt"); } + @Test @TestMetadata("ForInReversedReversedRange.kt") public void testForInReversedReversedRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInReversed/ForInReversedReversedRange.kt"); } + @Test @TestMetadata("forInReversedReversedReversedRange.kt") public void testForInReversedReversedReversedRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedReversedReversedRange.kt"); } + @Test @TestMetadata("forInReversedReversedUntil.kt") public void testForInReversedReversedUntil() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedReversedUntil.kt"); } + @Test @TestMetadata("forInReversedReversedUntilWithNonConstBounds.kt") public void testForInReversedReversedUntilWithNonConstBounds() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedReversedUntilWithNonConstBounds.kt"); } + @Test @TestMetadata("forInReversedUntil.kt") public void testForInReversedUntil() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedUntil.kt"); } + @Test @TestMetadata("forInReversedUntilWithNonConstBounds.kt") public void testForInReversedUntilWithNonConstBounds() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedUntilWithNonConstBounds.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/forInUntil") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ForInUntil extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ForInUntil { + @Test public void testAllFilesPresentInForInUntil() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInUntil"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("forInUntilChar.kt") public void testForInUntilChar() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilChar.kt"); } + @Test @TestMetadata("forInUntilCharMaxValue.kt") public void testForInUntilCharMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilCharMaxValue.kt"); } + @Test @TestMetadata("forInUntilCharMinValue.kt") public void testForInUntilCharMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilCharMinValue.kt"); } + @Test @TestMetadata("forInUntilCharMinValueNonConst.kt") public void testForInUntilCharMinValueNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilCharMinValueNonConst.kt"); } + @Test @TestMetadata("forInUntilInt.kt") public void testForInUntilInt() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilInt.kt"); } + @Test @TestMetadata("forInUntilIntMaxValue.kt") public void testForInUntilIntMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilIntMaxValue.kt"); } + @Test @TestMetadata("forInUntilIntMinValue.kt") public void testForInUntilIntMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilIntMinValue.kt"); } + @Test @TestMetadata("forInUntilIntMinValueNonConst.kt") public void testForInUntilIntMinValueNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilIntMinValueNonConst.kt"); } + @Test @TestMetadata("forInUntilLesserInt.kt") public void testForInUntilLesserInt() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilLesserInt.kt"); } + @Test @TestMetadata("forInUntilLong.kt") public void testForInUntilLong() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilLong.kt"); } + @Test @TestMetadata("forInUntilLongMaxValue.kt") public void testForInUntilLongMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilLongMaxValue.kt"); } + @Test @TestMetadata("forInUntilLongMinValue.kt") public void testForInUntilLongMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilLongMinValue.kt"); } + @Test @TestMetadata("forInUntilLongMinValueNonConst.kt") public void testForInUntilLongMinValueNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilLongMinValueNonConst.kt"); } + @Test @TestMetadata("forIntInIntUntilSmartcastInt.kt") public void testForIntInIntUntilSmartcastInt() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInUntil/forIntInIntUntilSmartcastInt.kt"); } + @Test @TestMetadata("kt42533.kt") public void testKt42533() throws Exception { runTest("compiler/testData/codegen/box/ranges/forInUntil/kt42533.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/forWithPossibleOverflow") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ForWithPossibleOverflow extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ForWithPossibleOverflow { + @Test public void testAllFilesPresentInForWithPossibleOverflow() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forWithPossibleOverflow"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("forInDownToCharMinValue.kt") public void testForInDownToCharMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInDownToCharMinValue.kt"); } + @Test @TestMetadata("forInDownToCharMinValueReversed.kt") public void testForInDownToCharMinValueReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInDownToCharMinValueReversed.kt"); } + @Test @TestMetadata("forInDownToIntMinValue.kt") public void testForInDownToIntMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInDownToIntMinValue.kt"); } + @Test @TestMetadata("forInDownToIntMinValueReversed.kt") public void testForInDownToIntMinValueReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInDownToIntMinValueReversed.kt"); } + @Test @TestMetadata("forInDownToLongMinValue.kt") public void testForInDownToLongMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInDownToLongMinValue.kt"); } + @Test @TestMetadata("forInDownToLongMinValueReversed.kt") public void testForInDownToLongMinValueReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInDownToLongMinValueReversed.kt"); } + @Test @TestMetadata("forInRangeToCharMaxValue.kt") public void testForInRangeToCharMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInRangeToCharMaxValue.kt"); } + @Test @TestMetadata("forInRangeToCharMaxValueReversed.kt") public void testForInRangeToCharMaxValueReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInRangeToCharMaxValueReversed.kt"); } + @Test @TestMetadata("forInRangeToIntMaxValue.kt") public void testForInRangeToIntMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInRangeToIntMaxValue.kt"); } + @Test @TestMetadata("forInRangeToIntMaxValueReversed.kt") public void testForInRangeToIntMaxValueReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInRangeToIntMaxValueReversed.kt"); } + @Test @TestMetadata("forInRangeToLongMaxValue.kt") public void testForInRangeToLongMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInRangeToLongMaxValue.kt"); } + @Test @TestMetadata("forInRangeToLongMaxValueReversed.kt") public void testForInRangeToLongMaxValueReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInRangeToLongMaxValueReversed.kt"); } + @Test @TestMetadata("forInUntilIntMinValueReversed.kt") public void testForInUntilIntMinValueReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInUntilIntMinValueReversed.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/javaInterop") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class JavaInterop extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class JavaInterop { + @Test public void testAllFilesPresentInJavaInterop() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/javaInterop/withIndex") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class WithIndex extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class WithIndex { + @Test public void testAllFilesPresentInWithIndex() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop/withIndex"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/literal") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Literal extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Literal { + @Test public void testAllFilesPresentInLiteral() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/literal"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("emptyDownto.kt") public void testEmptyDownto() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/emptyDownto.kt"); } + @Test @TestMetadata("emptyRange.kt") public void testEmptyRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/emptyRange.kt"); } + @Test @TestMetadata("inexactDownToMinValue.kt") public void testInexactDownToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/inexactDownToMinValue.kt"); } + @Test @TestMetadata("inexactSteppedDownTo.kt") public void testInexactSteppedDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/inexactSteppedDownTo.kt"); } + @Test @TestMetadata("inexactSteppedRange.kt") public void testInexactSteppedRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/inexactSteppedRange.kt"); } + @Test @TestMetadata("inexactToMaxValue.kt") public void testInexactToMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/inexactToMaxValue.kt"); } + @Test @TestMetadata("maxValueMinusTwoToMaxValue.kt") public void testMaxValueMinusTwoToMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/maxValueMinusTwoToMaxValue.kt"); } + @Test @TestMetadata("maxValueToMaxValue.kt") public void testMaxValueToMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/maxValueToMaxValue.kt"); } + @Test @TestMetadata("maxValueToMinValue.kt") public void testMaxValueToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/maxValueToMinValue.kt"); } + @Test @TestMetadata("oneElementDownTo.kt") public void testOneElementDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/oneElementDownTo.kt"); } + @Test @TestMetadata("oneElementRange.kt") public void testOneElementRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/oneElementRange.kt"); } + @Test @TestMetadata("openRange.kt") public void testOpenRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/openRange.kt"); } + @Test @TestMetadata("openRangeUntil.kt") public void testOpenRangeUntil() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/openRangeUntil.kt"); } + @Test @TestMetadata("overflowZeroDownToMaxValue.kt") public void testOverflowZeroDownToMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/overflowZeroDownToMaxValue.kt"); } + @Test @TestMetadata("overflowZeroToMinValue.kt") public void testOverflowZeroToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/overflowZeroToMinValue.kt"); } + @Test @TestMetadata("progressionDownToMinValue.kt") public void testProgressionDownToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/progressionDownToMinValue.kt"); } + @Test @TestMetadata("progressionMaxValueMinusTwoToMaxValue.kt") public void testProgressionMaxValueMinusTwoToMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/progressionMaxValueMinusTwoToMaxValue.kt"); } + @Test @TestMetadata("progressionMaxValueToMaxValue.kt") public void testProgressionMaxValueToMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/progressionMaxValueToMaxValue.kt"); } + @Test @TestMetadata("progressionMaxValueToMinValue.kt") public void testProgressionMaxValueToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/progressionMaxValueToMinValue.kt"); } + @Test @TestMetadata("progressionMinValueToMinValue.kt") public void testProgressionMinValueToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/progressionMinValueToMinValue.kt"); } + @Test @TestMetadata("reversedBackSequence.kt") public void testReversedBackSequence() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/reversedBackSequence.kt"); } + @Test @TestMetadata("reversedEmptyBackSequence.kt") public void testReversedEmptyBackSequence() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/reversedEmptyBackSequence.kt"); } + @Test @TestMetadata("reversedEmptyRange.kt") public void testReversedEmptyRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/reversedEmptyRange.kt"); } + @Test @TestMetadata("reversedInexactSteppedDownTo.kt") public void testReversedInexactSteppedDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/reversedInexactSteppedDownTo.kt"); } + @Test @TestMetadata("reversedRange.kt") public void testReversedRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/reversedRange.kt"); } + @Test @TestMetadata("reversedSimpleSteppedRange.kt") public void testReversedSimpleSteppedRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/reversedSimpleSteppedRange.kt"); } + @Test @TestMetadata("simpleDownTo.kt") public void testSimpleDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/simpleDownTo.kt"); } + @Test @TestMetadata("simpleRange.kt") public void testSimpleRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/simpleRange.kt"); } + @Test @TestMetadata("simpleRangeWithNonConstantEnds.kt") public void testSimpleRangeWithNonConstantEnds() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/simpleRangeWithNonConstantEnds.kt"); } + @Test @TestMetadata("simpleSteppedDownTo.kt") public void testSimpleSteppedDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/simpleSteppedDownTo.kt"); } + @Test @TestMetadata("simpleSteppedRange.kt") public void testSimpleSteppedRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/literal/simpleSteppedRange.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/nullableLoopParameter") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NullableLoopParameter extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NullableLoopParameter { + @Test public void testAllFilesPresentInNullableLoopParameter() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/nullableLoopParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("progressionExpression.kt") public void testProgressionExpression() throws Exception { runTest("compiler/testData/codegen/box/ranges/nullableLoopParameter/progressionExpression.kt"); } + @Test @TestMetadata("rangeExpression.kt") public void testRangeExpression() throws Exception { runTest("compiler/testData/codegen/box/ranges/nullableLoopParameter/rangeExpression.kt"); } + @Test @TestMetadata("rangeLiteral.kt") public void testRangeLiteral() throws Exception { runTest("compiler/testData/codegen/box/ranges/nullableLoopParameter/rangeLiteral.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Stepped extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Stepped { + @Test public void testAllFilesPresentInStepped() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Expression extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Expression { + @Test public void testAllFilesPresentInExpression() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/downTo") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DownTo extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DownTo { + @Test public void testAllFilesPresentInDownTo() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("emptyProgression.kt") public void testEmptyProgression() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/emptyProgression.kt"); } + @Test @TestMetadata("illegalStepNegative.kt") public void testIllegalStepNegative() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/illegalStepNegative.kt"); } + @Test @TestMetadata("illegalStepNonConst.kt") public void testIllegalStepNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/illegalStepNonConst.kt"); } + @Test @TestMetadata("illegalStepThenLegalStep.kt") public void testIllegalStepThenLegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/illegalStepThenLegalStep.kt"); } + @Test @TestMetadata("illegalStepZero.kt") public void testIllegalStepZero() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/illegalStepZero.kt"); } + @Test @TestMetadata("legalStepThenIllegalStep.kt") public void testLegalStepThenIllegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/legalStepThenIllegalStep.kt"); } + @Test @TestMetadata("maxValueToMinValueStepMaxValue.kt") public void testMaxValueToMinValueStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/maxValueToMinValueStepMaxValue.kt"); } + @Test @TestMetadata("maxValueToOneStepMaxValue.kt") public void testMaxValueToOneStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/maxValueToOneStepMaxValue.kt"); } + @Test @TestMetadata("maxValueToZeroStepMaxValue.kt") public void testMaxValueToZeroStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/maxValueToZeroStepMaxValue.kt"); } + @Test @TestMetadata("mixedTypeStep.kt") public void testMixedTypeStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/mixedTypeStep.kt"); } + @Test @TestMetadata("singleElementStepTwo.kt") public void testSingleElementStepTwo() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/singleElementStepTwo.kt"); } + @Test @TestMetadata("stepNonConst.kt") public void testStepNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/stepNonConst.kt"); } + @Test @TestMetadata("stepOne.kt") public void testStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/stepOne.kt"); } + @Test @TestMetadata("stepToOutsideRange.kt") public void testStepToOutsideRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/stepToOutsideRange.kt"); } + @Test @TestMetadata("stepToSameLast.kt") public void testStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/stepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLast.kt") public void testStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/stepToSmallerLast.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NestedStep extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NestedStep { + @Test public void testAllFilesPresentInNestedStep() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("stepOneThenStepOne.kt") public void testStepOneThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep/stepOneThenStepOne.kt"); } + @Test @TestMetadata("stepThenSameStep.kt") public void testStepThenSameStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep/stepThenSameStep.kt"); } + @Test @TestMetadata("stepToSameLastThenStepOne.kt") public void testStepToSameLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep/stepToSameLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSameLast.kt") public void testStepToSameLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep/stepToSameLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") public void testStepToSameLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepOne.kt") public void testStepToSmallerLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep/stepToSmallerLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") public void testStepToSmallerLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Reversed extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Reversed { + @Test public void testAllFilesPresentInReversed() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("reversedThenStep.kt") public void testReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed/reversedThenStep.kt"); } + @Test @TestMetadata("reversedThenStepThenReversed.kt") public void testReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed/reversedThenStepThenReversed.kt"); } + @Test @TestMetadata("reversedThenStepThenReversedThenStep.kt") public void testReversedThenStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed/reversedThenStepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversed.kt") public void testStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed/stepThenReversed.kt"); } + @Test @TestMetadata("stepThenReversedThenStep.kt") public void testStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed/stepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversedThenStepThenReversed.kt") public void testStepThenReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed/stepThenReversedThenStepThenReversed.kt"); @@ -25457,188 +28561,209 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class RangeTo extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class RangeTo { + @Test public void testAllFilesPresentInRangeTo() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("emptyProgression.kt") public void testEmptyProgression() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/emptyProgression.kt"); } + @Test @TestMetadata("illegalStepNegative.kt") public void testIllegalStepNegative() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/illegalStepNegative.kt"); } + @Test @TestMetadata("illegalStepNonConst.kt") public void testIllegalStepNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/illegalStepNonConst.kt"); } + @Test @TestMetadata("illegalStepThenLegalStep.kt") public void testIllegalStepThenLegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/illegalStepThenLegalStep.kt"); } + @Test @TestMetadata("illegalStepZero.kt") public void testIllegalStepZero() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/illegalStepZero.kt"); } + @Test @TestMetadata("legalStepThenIllegalStep.kt") public void testLegalStepThenIllegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/legalStepThenIllegalStep.kt"); } + @Test @TestMetadata("minValueToMaxValueStepMaxValue.kt") public void testMinValueToMaxValueStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/minValueToMaxValueStepMaxValue.kt"); } + @Test @TestMetadata("mixedTypeStep.kt") public void testMixedTypeStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/mixedTypeStep.kt"); } + @Test @TestMetadata("oneToMaxValueStepMaxValue.kt") public void testOneToMaxValueStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/oneToMaxValueStepMaxValue.kt"); } + @Test @TestMetadata("singleElementStepTwo.kt") public void testSingleElementStepTwo() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/singleElementStepTwo.kt"); } + @Test @TestMetadata("stepNonConst.kt") public void testStepNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/stepNonConst.kt"); } + @Test @TestMetadata("stepOne.kt") public void testStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/stepOne.kt"); } + @Test @TestMetadata("stepToOutsideRange.kt") public void testStepToOutsideRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/stepToOutsideRange.kt"); } + @Test @TestMetadata("stepToSameLast.kt") public void testStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/stepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLast.kt") public void testStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/stepToSmallerLast.kt"); } + @Test @TestMetadata("zeroToMaxValueStepMaxValue.kt") public void testZeroToMaxValueStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/zeroToMaxValueStepMaxValue.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NestedStep extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NestedStep { + @Test public void testAllFilesPresentInNestedStep() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("stepOneThenStepOne.kt") public void testStepOneThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep/stepOneThenStepOne.kt"); } + @Test @TestMetadata("stepThenSameStep.kt") public void testStepThenSameStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep/stepThenSameStep.kt"); } + @Test @TestMetadata("stepToSameLastThenStepOne.kt") public void testStepToSameLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep/stepToSameLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSameLast.kt") public void testStepToSameLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep/stepToSameLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") public void testStepToSameLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepOne.kt") public void testStepToSmallerLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep/stepToSmallerLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") public void testStepToSmallerLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Reversed extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Reversed { + @Test public void testAllFilesPresentInReversed() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("reversedThenStep.kt") public void testReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed/reversedThenStep.kt"); } + @Test @TestMetadata("reversedThenStepThenReversed.kt") public void testReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed/reversedThenStepThenReversed.kt"); } + @Test @TestMetadata("reversedThenStepThenReversedThenStep.kt") public void testReversedThenStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed/reversedThenStepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversed.kt") public void testStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed/stepThenReversed.kt"); } + @Test @TestMetadata("stepThenReversedThenStep.kt") public void testStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed/stepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversedThenStepThenReversed.kt") public void testStepThenReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed/stepThenReversedThenStepThenReversed.kt"); @@ -25646,158 +28771,173 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class RangeUntil extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class RangeUntil { + @Test public void testAllFilesPresentInRangeUntil() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("emptyProgression.kt") public void testEmptyProgression() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/emptyProgression.kt"); } + @Test @TestMetadata("illegalStepNegative.kt") public void testIllegalStepNegative() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/illegalStepNegative.kt"); } + @Test @TestMetadata("illegalStepThenLegalStep.kt") public void testIllegalStepThenLegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/illegalStepThenLegalStep.kt"); } + @Test @TestMetadata("illegalStepZero.kt") public void testIllegalStepZero() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/illegalStepZero.kt"); } + @Test @TestMetadata("legalStepThenIllegalStep.kt") public void testLegalStepThenIllegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/legalStepThenIllegalStep.kt"); } + @Test @TestMetadata("singleElementStepTwo.kt") public void testSingleElementStepTwo() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/singleElementStepTwo.kt"); } + @Test @TestMetadata("stepOne.kt") public void testStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepOne.kt"); } + @Test @TestMetadata("stepToOutsideRange.kt") public void testStepToOutsideRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepToOutsideRange.kt"); } + @Test @TestMetadata("stepToSameLast.kt") public void testStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLast.kt") public void testStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepToSmallerLast.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NestedStep extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NestedStep { + @Test public void testAllFilesPresentInNestedStep() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("stepOneThenStepOne.kt") public void testStepOneThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepOneThenStepOne.kt"); } + @Test @TestMetadata("stepThenSameStep.kt") public void testStepThenSameStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepThenSameStep.kt"); } + @Test @TestMetadata("stepToSameLastThenStepOne.kt") public void testStepToSameLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSameLast.kt") public void testStepToSameLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") public void testStepToSameLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepOne.kt") public void testStepToSmallerLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") public void testStepToSmallerLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Reversed extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Reversed { + @Test public void testAllFilesPresentInReversed() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("reversedThenStep.kt") public void testReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/reversedThenStep.kt"); } + @Test @TestMetadata("reversedThenStepThenReversed.kt") public void testReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/reversedThenStepThenReversed.kt"); } + @Test @TestMetadata("reversedThenStepThenReversedThenStep.kt") public void testReversedThenStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversed.kt") public void testStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/stepThenReversed.kt"); } + @Test @TestMetadata("stepThenReversedThenStep.kt") public void testStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/stepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversedThenStepThenReversed.kt") public void testStepThenReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt"); @@ -25805,193 +28945,215 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/until") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Until extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Until { + @Test public void testAllFilesPresentInUntil() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("emptyProgression.kt") public void testEmptyProgression() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/emptyProgression.kt"); } + @Test @TestMetadata("emptyProgressionToMinValue.kt") public void testEmptyProgressionToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/emptyProgressionToMinValue.kt"); } + @Test @TestMetadata("illegalStepNegative.kt") public void testIllegalStepNegative() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/illegalStepNegative.kt"); } + @Test @TestMetadata("illegalStepNonConst.kt") public void testIllegalStepNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/illegalStepNonConst.kt"); } + @Test @TestMetadata("illegalStepThenLegalStep.kt") public void testIllegalStepThenLegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/illegalStepThenLegalStep.kt"); } + @Test @TestMetadata("illegalStepZero.kt") public void testIllegalStepZero() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/illegalStepZero.kt"); } + @Test @TestMetadata("legalStepThenIllegalStep.kt") public void testLegalStepThenIllegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/legalStepThenIllegalStep.kt"); } + @Test @TestMetadata("minValueToMaxValueStepMaxValue.kt") public void testMinValueToMaxValueStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/minValueToMaxValueStepMaxValue.kt"); } + @Test @TestMetadata("mixedTypeStep.kt") public void testMixedTypeStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/mixedTypeStep.kt"); } + @Test @TestMetadata("progressionToNonConst.kt") public void testProgressionToNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/progressionToNonConst.kt"); } + @Test @TestMetadata("singleElementStepTwo.kt") public void testSingleElementStepTwo() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/singleElementStepTwo.kt"); } + @Test @TestMetadata("stepNonConst.kt") public void testStepNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/stepNonConst.kt"); } + @Test @TestMetadata("stepOne.kt") public void testStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/stepOne.kt"); } + @Test @TestMetadata("stepToOutsideRange.kt") public void testStepToOutsideRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/stepToOutsideRange.kt"); } + @Test @TestMetadata("stepToSameLast.kt") public void testStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/stepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLast.kt") public void testStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/stepToSmallerLast.kt"); } + @Test @TestMetadata("zeroToMaxValueStepMaxValue.kt") public void testZeroToMaxValueStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/zeroToMaxValueStepMaxValue.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NestedStep extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NestedStep { + @Test public void testAllFilesPresentInNestedStep() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("stepOneThenStepOne.kt") public void testStepOneThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep/stepOneThenStepOne.kt"); } + @Test @TestMetadata("stepThenSameStep.kt") public void testStepThenSameStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep/stepThenSameStep.kt"); } + @Test @TestMetadata("stepToSameLastThenStepOne.kt") public void testStepToSameLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep/stepToSameLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSameLast.kt") public void testStepToSameLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep/stepToSameLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") public void testStepToSameLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepOne.kt") public void testStepToSmallerLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep/stepToSmallerLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") public void testStepToSmallerLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Reversed extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Reversed { + @Test public void testAllFilesPresentInReversed() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("reversedThenStep.kt") public void testReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed/reversedThenStep.kt"); } + @Test @TestMetadata("reversedThenStepThenReversed.kt") public void testReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed/reversedThenStepThenReversed.kt"); } + @Test @TestMetadata("reversedThenStepThenReversedThenStep.kt") public void testReversedThenStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed/reversedThenStepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversed.kt") public void testStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed/stepThenReversed.kt"); } + @Test @TestMetadata("stepThenReversedThenStep.kt") public void testStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed/stepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversedThenStepThenReversed.kt") public void testStepThenReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed/stepThenReversedThenStepThenReversed.kt"); @@ -26000,200 +29162,218 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Literal extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Literal { + @Test public void testAllFilesPresentInLiteral() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/downTo") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DownTo extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DownTo { + @Test public void testAllFilesPresentInDownTo() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("emptyProgression.kt") public void testEmptyProgression() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/emptyProgression.kt"); } + @Test @TestMetadata("illegalStepNegative.kt") public void testIllegalStepNegative() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/illegalStepNegative.kt"); } + @Test @TestMetadata("illegalStepNonConst.kt") public void testIllegalStepNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/illegalStepNonConst.kt"); } + @Test @TestMetadata("illegalStepThenLegalStep.kt") public void testIllegalStepThenLegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/illegalStepThenLegalStep.kt"); } + @Test @TestMetadata("illegalStepZero.kt") public void testIllegalStepZero() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/illegalStepZero.kt"); } + @Test @TestMetadata("legalStepThenIllegalStep.kt") public void testLegalStepThenIllegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/legalStepThenIllegalStep.kt"); } + @Test @TestMetadata("maxValueToMinValueStepMaxValue.kt") public void testMaxValueToMinValueStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/maxValueToMinValueStepMaxValue.kt"); } + @Test @TestMetadata("maxValueToOneStepMaxValue.kt") public void testMaxValueToOneStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/maxValueToOneStepMaxValue.kt"); } + @Test @TestMetadata("maxValueToZeroStepMaxValue.kt") public void testMaxValueToZeroStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/maxValueToZeroStepMaxValue.kt"); } + @Test @TestMetadata("mixedTypeStep.kt") public void testMixedTypeStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/mixedTypeStep.kt"); } + @Test @TestMetadata("singleElementStepTwo.kt") public void testSingleElementStepTwo() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/singleElementStepTwo.kt"); } + @Test @TestMetadata("stepNonConst.kt") public void testStepNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/stepNonConst.kt"); } + @Test @TestMetadata("stepOne.kt") public void testStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/stepOne.kt"); } + @Test @TestMetadata("stepToOutsideRange.kt") public void testStepToOutsideRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/stepToOutsideRange.kt"); } + @Test @TestMetadata("stepToSameLast.kt") public void testStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/stepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLast.kt") public void testStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/stepToSmallerLast.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NestedStep extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NestedStep { + @Test public void testAllFilesPresentInNestedStep() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("stepOneThenStepOne.kt") public void testStepOneThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep/stepOneThenStepOne.kt"); } + @Test @TestMetadata("stepThenSameStep.kt") public void testStepThenSameStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep/stepThenSameStep.kt"); } + @Test @TestMetadata("stepToSameLastThenStepOne.kt") public void testStepToSameLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep/stepToSameLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSameLast.kt") public void testStepToSameLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep/stepToSameLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") public void testStepToSameLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepOne.kt") public void testStepToSmallerLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep/stepToSmallerLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") public void testStepToSmallerLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Reversed extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Reversed { + @Test public void testAllFilesPresentInReversed() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("reversedThenStep.kt") public void testReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed/reversedThenStep.kt"); } + @Test @TestMetadata("reversedThenStepThenReversed.kt") public void testReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed/reversedThenStepThenReversed.kt"); } + @Test @TestMetadata("reversedThenStepThenReversedThenStep.kt") public void testReversedThenStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed/reversedThenStepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversed.kt") public void testStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed/stepThenReversed.kt"); } + @Test @TestMetadata("stepThenReversedThenStep.kt") public void testStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed/stepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversedThenStepThenReversed.kt") public void testStepThenReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed/stepThenReversedThenStepThenReversed.kt"); @@ -26201,188 +29381,209 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class RangeTo extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class RangeTo { + @Test public void testAllFilesPresentInRangeTo() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("emptyProgression.kt") public void testEmptyProgression() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/emptyProgression.kt"); } + @Test @TestMetadata("illegalStepNegative.kt") public void testIllegalStepNegative() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/illegalStepNegative.kt"); } + @Test @TestMetadata("illegalStepNonConst.kt") public void testIllegalStepNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/illegalStepNonConst.kt"); } + @Test @TestMetadata("illegalStepThenLegalStep.kt") public void testIllegalStepThenLegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/illegalStepThenLegalStep.kt"); } + @Test @TestMetadata("illegalStepZero.kt") public void testIllegalStepZero() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/illegalStepZero.kt"); } + @Test @TestMetadata("legalStepThenIllegalStep.kt") public void testLegalStepThenIllegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/legalStepThenIllegalStep.kt"); } + @Test @TestMetadata("minValueToMaxValueStepMaxValue.kt") public void testMinValueToMaxValueStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/minValueToMaxValueStepMaxValue.kt"); } + @Test @TestMetadata("mixedTypeStep.kt") public void testMixedTypeStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/mixedTypeStep.kt"); } + @Test @TestMetadata("oneToMaxValueStepMaxValue.kt") public void testOneToMaxValueStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/oneToMaxValueStepMaxValue.kt"); } + @Test @TestMetadata("singleElementStepTwo.kt") public void testSingleElementStepTwo() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/singleElementStepTwo.kt"); } + @Test @TestMetadata("stepNonConst.kt") public void testStepNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/stepNonConst.kt"); } + @Test @TestMetadata("stepOne.kt") public void testStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/stepOne.kt"); } + @Test @TestMetadata("stepToOutsideRange.kt") public void testStepToOutsideRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/stepToOutsideRange.kt"); } + @Test @TestMetadata("stepToSameLast.kt") public void testStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/stepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLast.kt") public void testStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/stepToSmallerLast.kt"); } + @Test @TestMetadata("zeroToMaxValueStepMaxValue.kt") public void testZeroToMaxValueStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/zeroToMaxValueStepMaxValue.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NestedStep extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NestedStep { + @Test public void testAllFilesPresentInNestedStep() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("stepOneThenStepOne.kt") public void testStepOneThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep/stepOneThenStepOne.kt"); } + @Test @TestMetadata("stepThenSameStep.kt") public void testStepThenSameStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep/stepThenSameStep.kt"); } + @Test @TestMetadata("stepToSameLastThenStepOne.kt") public void testStepToSameLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep/stepToSameLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSameLast.kt") public void testStepToSameLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep/stepToSameLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") public void testStepToSameLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepOne.kt") public void testStepToSmallerLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep/stepToSmallerLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") public void testStepToSmallerLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Reversed extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Reversed { + @Test public void testAllFilesPresentInReversed() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("reversedThenStep.kt") public void testReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed/reversedThenStep.kt"); } + @Test @TestMetadata("reversedThenStepThenReversed.kt") public void testReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed/reversedThenStepThenReversed.kt"); } + @Test @TestMetadata("reversedThenStepThenReversedThenStep.kt") public void testReversedThenStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed/reversedThenStepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversed.kt") public void testStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed/stepThenReversed.kt"); } + @Test @TestMetadata("stepThenReversedThenStep.kt") public void testStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed/stepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversedThenStepThenReversed.kt") public void testStepThenReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed/stepThenReversedThenStepThenReversed.kt"); @@ -26390,158 +29591,173 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class RangeUntil extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class RangeUntil { + @Test public void testAllFilesPresentInRangeUntil() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("emptyProgression.kt") public void testEmptyProgression() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/emptyProgression.kt"); } + @Test @TestMetadata("illegalStepNegative.kt") public void testIllegalStepNegative() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/illegalStepNegative.kt"); } + @Test @TestMetadata("illegalStepThenLegalStep.kt") public void testIllegalStepThenLegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/illegalStepThenLegalStep.kt"); } + @Test @TestMetadata("illegalStepZero.kt") public void testIllegalStepZero() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/illegalStepZero.kt"); } + @Test @TestMetadata("legalStepThenIllegalStep.kt") public void testLegalStepThenIllegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/legalStepThenIllegalStep.kt"); } + @Test @TestMetadata("singleElementStepTwo.kt") public void testSingleElementStepTwo() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/singleElementStepTwo.kt"); } + @Test @TestMetadata("stepOne.kt") public void testStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepOne.kt"); } + @Test @TestMetadata("stepToOutsideRange.kt") public void testStepToOutsideRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepToOutsideRange.kt"); } + @Test @TestMetadata("stepToSameLast.kt") public void testStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLast.kt") public void testStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepToSmallerLast.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NestedStep extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NestedStep { + @Test public void testAllFilesPresentInNestedStep() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("stepOneThenStepOne.kt") public void testStepOneThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepOneThenStepOne.kt"); } + @Test @TestMetadata("stepThenSameStep.kt") public void testStepThenSameStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepThenSameStep.kt"); } + @Test @TestMetadata("stepToSameLastThenStepOne.kt") public void testStepToSameLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSameLast.kt") public void testStepToSameLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") public void testStepToSameLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepOne.kt") public void testStepToSmallerLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") public void testStepToSmallerLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Reversed extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Reversed { + @Test public void testAllFilesPresentInReversed() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("reversedThenStep.kt") public void testReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/reversedThenStep.kt"); } + @Test @TestMetadata("reversedThenStepThenReversed.kt") public void testReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/reversedThenStepThenReversed.kt"); } + @Test @TestMetadata("reversedThenStepThenReversedThenStep.kt") public void testReversedThenStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversed.kt") public void testStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/stepThenReversed.kt"); } + @Test @TestMetadata("stepThenReversedThenStep.kt") public void testStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/stepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversedThenStepThenReversed.kt") public void testStepThenReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt"); @@ -26549,193 +29765,215 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/until") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Until extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Until { + @Test public void testAllFilesPresentInUntil() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("emptyProgression.kt") public void testEmptyProgression() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/emptyProgression.kt"); } + @Test @TestMetadata("emptyProgressionToMinValue.kt") public void testEmptyProgressionToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/emptyProgressionToMinValue.kt"); } + @Test @TestMetadata("illegalStepNegative.kt") public void testIllegalStepNegative() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/illegalStepNegative.kt"); } + @Test @TestMetadata("illegalStepNonConst.kt") public void testIllegalStepNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/illegalStepNonConst.kt"); } + @Test @TestMetadata("illegalStepThenLegalStep.kt") public void testIllegalStepThenLegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/illegalStepThenLegalStep.kt"); } + @Test @TestMetadata("illegalStepZero.kt") public void testIllegalStepZero() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/illegalStepZero.kt"); } + @Test @TestMetadata("legalStepThenIllegalStep.kt") public void testLegalStepThenIllegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/legalStepThenIllegalStep.kt"); } + @Test @TestMetadata("minValueToMaxValueStepMaxValue.kt") public void testMinValueToMaxValueStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/minValueToMaxValueStepMaxValue.kt"); } + @Test @TestMetadata("mixedTypeStep.kt") public void testMixedTypeStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/mixedTypeStep.kt"); } + @Test @TestMetadata("progressionToNonConst.kt") public void testProgressionToNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/progressionToNonConst.kt"); } + @Test @TestMetadata("singleElementStepTwo.kt") public void testSingleElementStepTwo() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/singleElementStepTwo.kt"); } + @Test @TestMetadata("stepNonConst.kt") public void testStepNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/stepNonConst.kt"); } + @Test @TestMetadata("stepOne.kt") public void testStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/stepOne.kt"); } + @Test @TestMetadata("stepToOutsideRange.kt") public void testStepToOutsideRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/stepToOutsideRange.kt"); } + @Test @TestMetadata("stepToSameLast.kt") public void testStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/stepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLast.kt") public void testStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/stepToSmallerLast.kt"); } + @Test @TestMetadata("zeroToMaxValueStepMaxValue.kt") public void testZeroToMaxValueStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/zeroToMaxValueStepMaxValue.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NestedStep extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NestedStep { + @Test public void testAllFilesPresentInNestedStep() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("stepOneThenStepOne.kt") public void testStepOneThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep/stepOneThenStepOne.kt"); } + @Test @TestMetadata("stepThenSameStep.kt") public void testStepThenSameStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep/stepThenSameStep.kt"); } + @Test @TestMetadata("stepToSameLastThenStepOne.kt") public void testStepToSameLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep/stepToSameLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSameLast.kt") public void testStepToSameLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep/stepToSameLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") public void testStepToSameLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepOne.kt") public void testStepToSmallerLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep/stepToSmallerLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") public void testStepToSmallerLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Reversed extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Reversed { + @Test public void testAllFilesPresentInReversed() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("reversedThenStep.kt") public void testReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed/reversedThenStep.kt"); } + @Test @TestMetadata("reversedThenStepThenReversed.kt") public void testReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed/reversedThenStepThenReversed.kt"); } + @Test @TestMetadata("reversedThenStepThenReversedThenStep.kt") public void testReversedThenStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed/reversedThenStepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversed.kt") public void testStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed/stepThenReversed.kt"); } + @Test @TestMetadata("stepThenReversedThenStep.kt") public void testStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed/stepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversedThenStepThenReversed.kt") public void testStepThenReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed/stepThenReversedThenStepThenReversed.kt"); @@ -26744,212 +29982,227 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Unsigned extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Unsigned { + @Test public void testAllFilesPresentInUnsigned() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Expression extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Expression { + @Test public void testAllFilesPresentInExpression() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DownTo extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DownTo { + @Test public void testAllFilesPresentInDownTo() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("emptyProgression.kt") public void testEmptyProgression() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/emptyProgression.kt"); } + @Test @TestMetadata("illegalStepNegative.kt") public void testIllegalStepNegative() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/illegalStepNegative.kt"); } + @Test @TestMetadata("illegalStepNonConst.kt") public void testIllegalStepNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/illegalStepNonConst.kt"); } + @Test @TestMetadata("illegalStepThenLegalStep.kt") public void testIllegalStepThenLegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/illegalStepThenLegalStep.kt"); } + @Test @TestMetadata("illegalStepZero.kt") public void testIllegalStepZero() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/illegalStepZero.kt"); } + @Test @TestMetadata("legalStepThenIllegalStep.kt") public void testLegalStepThenIllegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/legalStepThenIllegalStep.kt"); } + @Test @TestMetadata("maxValueToMinValueStepMaxValue.kt") public void testMaxValueToMinValueStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/maxValueToMinValueStepMaxValue.kt"); } + @Test @TestMetadata("maxValueToOneStepMaxValue.kt") public void testMaxValueToOneStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/maxValueToOneStepMaxValue.kt"); } + @Test @TestMetadata("maxValueToZeroStepMaxValue.kt") public void testMaxValueToZeroStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/maxValueToZeroStepMaxValue.kt"); } + @Test @TestMetadata("mixedTypeStep.kt") public void testMixedTypeStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/mixedTypeStep.kt"); } + @Test @TestMetadata("singleElementStepTwo.kt") public void testSingleElementStepTwo() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/singleElementStepTwo.kt"); } + @Test @TestMetadata("stepNonConst.kt") public void testStepNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/stepNonConst.kt"); } + @Test @TestMetadata("stepOne.kt") public void testStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/stepOne.kt"); } + @Test @TestMetadata("stepToOutsideRange.kt") public void testStepToOutsideRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/stepToOutsideRange.kt"); } + @Test @TestMetadata("stepToSameLast.kt") public void testStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/stepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLast.kt") public void testStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/stepToSmallerLast.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NestedStep extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NestedStep { + @Test public void testAllFilesPresentInNestedStep() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("stepOneThenStepOne.kt") public void testStepOneThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep/stepOneThenStepOne.kt"); } + @Test @TestMetadata("stepThenSameStep.kt") public void testStepThenSameStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep/stepThenSameStep.kt"); } + @Test @TestMetadata("stepToSameLastThenStepOne.kt") public void testStepToSameLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep/stepToSameLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSameLast.kt") public void testStepToSameLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep/stepToSameLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") public void testStepToSameLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepOne.kt") public void testStepToSmallerLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep/stepToSmallerLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") public void testStepToSmallerLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Reversed extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Reversed { + @Test public void testAllFilesPresentInReversed() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("reversedThenStep.kt") public void testReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed/reversedThenStep.kt"); } + @Test @TestMetadata("reversedThenStepThenReversed.kt") public void testReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed/reversedThenStepThenReversed.kt"); } + @Test @TestMetadata("reversedThenStepThenReversedThenStep.kt") public void testReversedThenStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed/reversedThenStepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversed.kt") public void testStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed/stepThenReversed.kt"); } + @Test @TestMetadata("stepThenReversedThenStep.kt") public void testStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed/stepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversedThenStepThenReversed.kt") public void testStepThenReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed/stepThenReversedThenStepThenReversed.kt"); @@ -26957,188 +30210,209 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class RangeTo extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class RangeTo { + @Test public void testAllFilesPresentInRangeTo() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("emptyProgression.kt") public void testEmptyProgression() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/emptyProgression.kt"); } + @Test @TestMetadata("illegalStepNegative.kt") public void testIllegalStepNegative() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/illegalStepNegative.kt"); } + @Test @TestMetadata("illegalStepNonConst.kt") public void testIllegalStepNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/illegalStepNonConst.kt"); } + @Test @TestMetadata("illegalStepThenLegalStep.kt") public void testIllegalStepThenLegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/illegalStepThenLegalStep.kt"); } + @Test @TestMetadata("illegalStepZero.kt") public void testIllegalStepZero() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/illegalStepZero.kt"); } + @Test @TestMetadata("legalStepThenIllegalStep.kt") public void testLegalStepThenIllegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/legalStepThenIllegalStep.kt"); } + @Test @TestMetadata("minValueToMaxValueStepMaxValue.kt") public void testMinValueToMaxValueStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/minValueToMaxValueStepMaxValue.kt"); } + @Test @TestMetadata("mixedTypeStep.kt") public void testMixedTypeStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/mixedTypeStep.kt"); } + @Test @TestMetadata("oneToMaxValueStepMaxValue.kt") public void testOneToMaxValueStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/oneToMaxValueStepMaxValue.kt"); } + @Test @TestMetadata("singleElementStepTwo.kt") public void testSingleElementStepTwo() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/singleElementStepTwo.kt"); } + @Test @TestMetadata("stepNonConst.kt") public void testStepNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/stepNonConst.kt"); } + @Test @TestMetadata("stepOne.kt") public void testStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/stepOne.kt"); } + @Test @TestMetadata("stepToOutsideRange.kt") public void testStepToOutsideRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/stepToOutsideRange.kt"); } + @Test @TestMetadata("stepToSameLast.kt") public void testStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/stepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLast.kt") public void testStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/stepToSmallerLast.kt"); } + @Test @TestMetadata("zeroToMaxValueStepMaxValue.kt") public void testZeroToMaxValueStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/zeroToMaxValueStepMaxValue.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NestedStep extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NestedStep { + @Test public void testAllFilesPresentInNestedStep() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("stepOneThenStepOne.kt") public void testStepOneThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep/stepOneThenStepOne.kt"); } + @Test @TestMetadata("stepThenSameStep.kt") public void testStepThenSameStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep/stepThenSameStep.kt"); } + @Test @TestMetadata("stepToSameLastThenStepOne.kt") public void testStepToSameLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep/stepToSameLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSameLast.kt") public void testStepToSameLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep/stepToSameLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") public void testStepToSameLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepOne.kt") public void testStepToSmallerLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep/stepToSmallerLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") public void testStepToSmallerLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Reversed extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Reversed { + @Test public void testAllFilesPresentInReversed() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("reversedThenStep.kt") public void testReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed/reversedThenStep.kt"); } + @Test @TestMetadata("reversedThenStepThenReversed.kt") public void testReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed/reversedThenStepThenReversed.kt"); } + @Test @TestMetadata("reversedThenStepThenReversedThenStep.kt") public void testReversedThenStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed/reversedThenStepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversed.kt") public void testStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed/stepThenReversed.kt"); } + @Test @TestMetadata("stepThenReversedThenStep.kt") public void testStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed/stepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversedThenStepThenReversed.kt") public void testStepThenReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed/stepThenReversedThenStepThenReversed.kt"); @@ -27146,158 +30420,173 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class RangeUntil extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class RangeUntil { + @Test public void testAllFilesPresentInRangeUntil() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("emptyProgression.kt") public void testEmptyProgression() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/emptyProgression.kt"); } + @Test @TestMetadata("illegalStepNegative.kt") public void testIllegalStepNegative() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/illegalStepNegative.kt"); } + @Test @TestMetadata("illegalStepThenLegalStep.kt") public void testIllegalStepThenLegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/illegalStepThenLegalStep.kt"); } + @Test @TestMetadata("illegalStepZero.kt") public void testIllegalStepZero() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/illegalStepZero.kt"); } + @Test @TestMetadata("legalStepThenIllegalStep.kt") public void testLegalStepThenIllegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/legalStepThenIllegalStep.kt"); } + @Test @TestMetadata("singleElementStepTwo.kt") public void testSingleElementStepTwo() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/singleElementStepTwo.kt"); } + @Test @TestMetadata("stepOne.kt") public void testStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepOne.kt"); } + @Test @TestMetadata("stepToOutsideRange.kt") public void testStepToOutsideRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepToOutsideRange.kt"); } + @Test @TestMetadata("stepToSameLast.kt") public void testStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLast.kt") public void testStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepToSmallerLast.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NestedStep extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NestedStep { + @Test public void testAllFilesPresentInNestedStep() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("stepOneThenStepOne.kt") public void testStepOneThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepOneThenStepOne.kt"); } + @Test @TestMetadata("stepThenSameStep.kt") public void testStepThenSameStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepThenSameStep.kt"); } + @Test @TestMetadata("stepToSameLastThenStepOne.kt") public void testStepToSameLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSameLast.kt") public void testStepToSameLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") public void testStepToSameLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepOne.kt") public void testStepToSmallerLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") public void testStepToSmallerLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Reversed extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Reversed { + @Test public void testAllFilesPresentInReversed() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("reversedThenStep.kt") public void testReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/reversedThenStep.kt"); } + @Test @TestMetadata("reversedThenStepThenReversed.kt") public void testReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/reversedThenStepThenReversed.kt"); } + @Test @TestMetadata("reversedThenStepThenReversedThenStep.kt") public void testReversedThenStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversed.kt") public void testStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/stepThenReversed.kt"); } + @Test @TestMetadata("stepThenReversedThenStep.kt") public void testStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/stepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversedThenStepThenReversed.kt") public void testStepThenReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt"); @@ -27305,193 +30594,215 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Until extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Until { + @Test public void testAllFilesPresentInUntil() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("emptyProgression.kt") public void testEmptyProgression() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/emptyProgression.kt"); } + @Test @TestMetadata("emptyProgressionToMinValue.kt") public void testEmptyProgressionToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/emptyProgressionToMinValue.kt"); } + @Test @TestMetadata("illegalStepNegative.kt") public void testIllegalStepNegative() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/illegalStepNegative.kt"); } + @Test @TestMetadata("illegalStepNonConst.kt") public void testIllegalStepNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/illegalStepNonConst.kt"); } + @Test @TestMetadata("illegalStepThenLegalStep.kt") public void testIllegalStepThenLegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/illegalStepThenLegalStep.kt"); } + @Test @TestMetadata("illegalStepZero.kt") public void testIllegalStepZero() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/illegalStepZero.kt"); } + @Test @TestMetadata("legalStepThenIllegalStep.kt") public void testLegalStepThenIllegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/legalStepThenIllegalStep.kt"); } + @Test @TestMetadata("minValueToMaxValueStepMaxValue.kt") public void testMinValueToMaxValueStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/minValueToMaxValueStepMaxValue.kt"); } + @Test @TestMetadata("mixedTypeStep.kt") public void testMixedTypeStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/mixedTypeStep.kt"); } + @Test @TestMetadata("progressionToNonConst.kt") public void testProgressionToNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/progressionToNonConst.kt"); } + @Test @TestMetadata("singleElementStepTwo.kt") public void testSingleElementStepTwo() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/singleElementStepTwo.kt"); } + @Test @TestMetadata("stepNonConst.kt") public void testStepNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/stepNonConst.kt"); } + @Test @TestMetadata("stepOne.kt") public void testStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/stepOne.kt"); } + @Test @TestMetadata("stepToOutsideRange.kt") public void testStepToOutsideRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/stepToOutsideRange.kt"); } + @Test @TestMetadata("stepToSameLast.kt") public void testStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/stepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLast.kt") public void testStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/stepToSmallerLast.kt"); } + @Test @TestMetadata("zeroToMaxValueStepMaxValue.kt") public void testZeroToMaxValueStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/zeroToMaxValueStepMaxValue.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NestedStep extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NestedStep { + @Test public void testAllFilesPresentInNestedStep() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("stepOneThenStepOne.kt") public void testStepOneThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep/stepOneThenStepOne.kt"); } + @Test @TestMetadata("stepThenSameStep.kt") public void testStepThenSameStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep/stepThenSameStep.kt"); } + @Test @TestMetadata("stepToSameLastThenStepOne.kt") public void testStepToSameLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep/stepToSameLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSameLast.kt") public void testStepToSameLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep/stepToSameLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") public void testStepToSameLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepOne.kt") public void testStepToSmallerLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep/stepToSmallerLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") public void testStepToSmallerLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Reversed extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Reversed { + @Test public void testAllFilesPresentInReversed() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("reversedThenStep.kt") public void testReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed/reversedThenStep.kt"); } + @Test @TestMetadata("reversedThenStepThenReversed.kt") public void testReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed/reversedThenStepThenReversed.kt"); } + @Test @TestMetadata("reversedThenStepThenReversedThenStep.kt") public void testReversedThenStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed/reversedThenStepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversed.kt") public void testStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed/stepThenReversed.kt"); } + @Test @TestMetadata("stepThenReversedThenStep.kt") public void testStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed/stepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversedThenStepThenReversed.kt") public void testStepThenReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed/stepThenReversedThenStepThenReversed.kt"); @@ -27500,200 +30811,218 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Literal extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Literal { + @Test public void testAllFilesPresentInLiteral() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class DownTo extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class DownTo { + @Test public void testAllFilesPresentInDownTo() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("emptyProgression.kt") public void testEmptyProgression() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/emptyProgression.kt"); } + @Test @TestMetadata("illegalStepNegative.kt") public void testIllegalStepNegative() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/illegalStepNegative.kt"); } + @Test @TestMetadata("illegalStepNonConst.kt") public void testIllegalStepNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/illegalStepNonConst.kt"); } + @Test @TestMetadata("illegalStepThenLegalStep.kt") public void testIllegalStepThenLegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/illegalStepThenLegalStep.kt"); } + @Test @TestMetadata("illegalStepZero.kt") public void testIllegalStepZero() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/illegalStepZero.kt"); } + @Test @TestMetadata("legalStepThenIllegalStep.kt") public void testLegalStepThenIllegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/legalStepThenIllegalStep.kt"); } + @Test @TestMetadata("maxValueToMinValueStepMaxValue.kt") public void testMaxValueToMinValueStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/maxValueToMinValueStepMaxValue.kt"); } + @Test @TestMetadata("maxValueToOneStepMaxValue.kt") public void testMaxValueToOneStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/maxValueToOneStepMaxValue.kt"); } + @Test @TestMetadata("maxValueToZeroStepMaxValue.kt") public void testMaxValueToZeroStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/maxValueToZeroStepMaxValue.kt"); } + @Test @TestMetadata("mixedTypeStep.kt") public void testMixedTypeStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/mixedTypeStep.kt"); } + @Test @TestMetadata("singleElementStepTwo.kt") public void testSingleElementStepTwo() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/singleElementStepTwo.kt"); } + @Test @TestMetadata("stepNonConst.kt") public void testStepNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/stepNonConst.kt"); } + @Test @TestMetadata("stepOne.kt") public void testStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/stepOne.kt"); } + @Test @TestMetadata("stepToOutsideRange.kt") public void testStepToOutsideRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/stepToOutsideRange.kt"); } + @Test @TestMetadata("stepToSameLast.kt") public void testStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/stepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLast.kt") public void testStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/stepToSmallerLast.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NestedStep extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NestedStep { + @Test public void testAllFilesPresentInNestedStep() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("stepOneThenStepOne.kt") public void testStepOneThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep/stepOneThenStepOne.kt"); } + @Test @TestMetadata("stepThenSameStep.kt") public void testStepThenSameStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep/stepThenSameStep.kt"); } + @Test @TestMetadata("stepToSameLastThenStepOne.kt") public void testStepToSameLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep/stepToSameLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSameLast.kt") public void testStepToSameLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep/stepToSameLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") public void testStepToSameLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepOne.kt") public void testStepToSmallerLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep/stepToSmallerLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") public void testStepToSmallerLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Reversed extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Reversed { + @Test public void testAllFilesPresentInReversed() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("reversedThenStep.kt") public void testReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed/reversedThenStep.kt"); } + @Test @TestMetadata("reversedThenStepThenReversed.kt") public void testReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed/reversedThenStepThenReversed.kt"); } + @Test @TestMetadata("reversedThenStepThenReversedThenStep.kt") public void testReversedThenStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed/reversedThenStepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversed.kt") public void testStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed/stepThenReversed.kt"); } + @Test @TestMetadata("stepThenReversedThenStep.kt") public void testStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed/stepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversedThenStepThenReversed.kt") public void testStepThenReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed/stepThenReversedThenStepThenReversed.kt"); @@ -27701,188 +31030,209 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class RangeTo extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class RangeTo { + @Test public void testAllFilesPresentInRangeTo() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("emptyProgression.kt") public void testEmptyProgression() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/emptyProgression.kt"); } + @Test @TestMetadata("illegalStepNegative.kt") public void testIllegalStepNegative() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/illegalStepNegative.kt"); } + @Test @TestMetadata("illegalStepNonConst.kt") public void testIllegalStepNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/illegalStepNonConst.kt"); } + @Test @TestMetadata("illegalStepThenLegalStep.kt") public void testIllegalStepThenLegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/illegalStepThenLegalStep.kt"); } + @Test @TestMetadata("illegalStepZero.kt") public void testIllegalStepZero() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/illegalStepZero.kt"); } + @Test @TestMetadata("legalStepThenIllegalStep.kt") public void testLegalStepThenIllegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/legalStepThenIllegalStep.kt"); } + @Test @TestMetadata("minValueToMaxValueStepMaxValue.kt") public void testMinValueToMaxValueStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/minValueToMaxValueStepMaxValue.kt"); } + @Test @TestMetadata("mixedTypeStep.kt") public void testMixedTypeStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/mixedTypeStep.kt"); } + @Test @TestMetadata("oneToMaxValueStepMaxValue.kt") public void testOneToMaxValueStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/oneToMaxValueStepMaxValue.kt"); } + @Test @TestMetadata("singleElementStepTwo.kt") public void testSingleElementStepTwo() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/singleElementStepTwo.kt"); } + @Test @TestMetadata("stepNonConst.kt") public void testStepNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/stepNonConst.kt"); } + @Test @TestMetadata("stepOne.kt") public void testStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/stepOne.kt"); } + @Test @TestMetadata("stepToOutsideRange.kt") public void testStepToOutsideRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/stepToOutsideRange.kt"); } + @Test @TestMetadata("stepToSameLast.kt") public void testStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/stepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLast.kt") public void testStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/stepToSmallerLast.kt"); } + @Test @TestMetadata("zeroToMaxValueStepMaxValue.kt") public void testZeroToMaxValueStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/zeroToMaxValueStepMaxValue.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NestedStep extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NestedStep { + @Test public void testAllFilesPresentInNestedStep() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("stepOneThenStepOne.kt") public void testStepOneThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep/stepOneThenStepOne.kt"); } + @Test @TestMetadata("stepThenSameStep.kt") public void testStepThenSameStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep/stepThenSameStep.kt"); } + @Test @TestMetadata("stepToSameLastThenStepOne.kt") public void testStepToSameLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep/stepToSameLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSameLast.kt") public void testStepToSameLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep/stepToSameLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") public void testStepToSameLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepOne.kt") public void testStepToSmallerLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep/stepToSmallerLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") public void testStepToSmallerLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Reversed extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Reversed { + @Test public void testAllFilesPresentInReversed() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("reversedThenStep.kt") public void testReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed/reversedThenStep.kt"); } + @Test @TestMetadata("reversedThenStepThenReversed.kt") public void testReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed/reversedThenStepThenReversed.kt"); } + @Test @TestMetadata("reversedThenStepThenReversedThenStep.kt") public void testReversedThenStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed/reversedThenStepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversed.kt") public void testStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed/stepThenReversed.kt"); } + @Test @TestMetadata("stepThenReversedThenStep.kt") public void testStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed/stepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversedThenStepThenReversed.kt") public void testStepThenReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed/stepThenReversedThenStepThenReversed.kt"); @@ -27890,158 +31240,173 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class RangeUntil extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class RangeUntil { + @Test public void testAllFilesPresentInRangeUntil() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("emptyProgression.kt") public void testEmptyProgression() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/emptyProgression.kt"); } + @Test @TestMetadata("illegalStepNegative.kt") public void testIllegalStepNegative() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/illegalStepNegative.kt"); } + @Test @TestMetadata("illegalStepThenLegalStep.kt") public void testIllegalStepThenLegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/illegalStepThenLegalStep.kt"); } + @Test @TestMetadata("illegalStepZero.kt") public void testIllegalStepZero() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/illegalStepZero.kt"); } + @Test @TestMetadata("legalStepThenIllegalStep.kt") public void testLegalStepThenIllegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/legalStepThenIllegalStep.kt"); } + @Test @TestMetadata("singleElementStepTwo.kt") public void testSingleElementStepTwo() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/singleElementStepTwo.kt"); } + @Test @TestMetadata("stepOne.kt") public void testStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepOne.kt"); } + @Test @TestMetadata("stepToOutsideRange.kt") public void testStepToOutsideRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepToOutsideRange.kt"); } + @Test @TestMetadata("stepToSameLast.kt") public void testStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLast.kt") public void testStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepToSmallerLast.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NestedStep extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NestedStep { + @Test public void testAllFilesPresentInNestedStep() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("stepOneThenStepOne.kt") public void testStepOneThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepOneThenStepOne.kt"); } + @Test @TestMetadata("stepThenSameStep.kt") public void testStepThenSameStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepThenSameStep.kt"); } + @Test @TestMetadata("stepToSameLastThenStepOne.kt") public void testStepToSameLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSameLast.kt") public void testStepToSameLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") public void testStepToSameLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepOne.kt") public void testStepToSmallerLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") public void testStepToSmallerLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Reversed extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Reversed { + @Test public void testAllFilesPresentInReversed() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("reversedThenStep.kt") public void testReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/reversedThenStep.kt"); } + @Test @TestMetadata("reversedThenStepThenReversed.kt") public void testReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/reversedThenStepThenReversed.kt"); } + @Test @TestMetadata("reversedThenStepThenReversedThenStep.kt") public void testReversedThenStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversed.kt") public void testStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/stepThenReversed.kt"); } + @Test @TestMetadata("stepThenReversedThenStep.kt") public void testStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/stepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversedThenStepThenReversed.kt") public void testStepThenReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt"); @@ -28049,193 +31414,215 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Until extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Until { + @Test public void testAllFilesPresentInUntil() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("emptyProgression.kt") public void testEmptyProgression() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/emptyProgression.kt"); } + @Test @TestMetadata("emptyProgressionToMinValue.kt") public void testEmptyProgressionToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/emptyProgressionToMinValue.kt"); } + @Test @TestMetadata("illegalStepNegative.kt") public void testIllegalStepNegative() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/illegalStepNegative.kt"); } + @Test @TestMetadata("illegalStepNonConst.kt") public void testIllegalStepNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/illegalStepNonConst.kt"); } + @Test @TestMetadata("illegalStepThenLegalStep.kt") public void testIllegalStepThenLegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/illegalStepThenLegalStep.kt"); } + @Test @TestMetadata("illegalStepZero.kt") public void testIllegalStepZero() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/illegalStepZero.kt"); } + @Test @TestMetadata("legalStepThenIllegalStep.kt") public void testLegalStepThenIllegalStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/legalStepThenIllegalStep.kt"); } + @Test @TestMetadata("minValueToMaxValueStepMaxValue.kt") public void testMinValueToMaxValueStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/minValueToMaxValueStepMaxValue.kt"); } + @Test @TestMetadata("mixedTypeStep.kt") public void testMixedTypeStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/mixedTypeStep.kt"); } + @Test @TestMetadata("progressionToNonConst.kt") public void testProgressionToNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/progressionToNonConst.kt"); } + @Test @TestMetadata("singleElementStepTwo.kt") public void testSingleElementStepTwo() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/singleElementStepTwo.kt"); } + @Test @TestMetadata("stepNonConst.kt") public void testStepNonConst() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/stepNonConst.kt"); } + @Test @TestMetadata("stepOne.kt") public void testStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/stepOne.kt"); } + @Test @TestMetadata("stepToOutsideRange.kt") public void testStepToOutsideRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/stepToOutsideRange.kt"); } + @Test @TestMetadata("stepToSameLast.kt") public void testStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/stepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLast.kt") public void testStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/stepToSmallerLast.kt"); } + @Test @TestMetadata("zeroToMaxValueStepMaxValue.kt") public void testZeroToMaxValueStepMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/zeroToMaxValueStepMaxValue.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NestedStep extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NestedStep { + @Test public void testAllFilesPresentInNestedStep() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("stepOneThenStepOne.kt") public void testStepOneThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep/stepOneThenStepOne.kt"); } + @Test @TestMetadata("stepThenSameStep.kt") public void testStepThenSameStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep/stepThenSameStep.kt"); } + @Test @TestMetadata("stepToSameLastThenStepOne.kt") public void testStepToSameLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep/stepToSameLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSameLast.kt") public void testStepToSameLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep/stepToSameLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") public void testStepToSameLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepOne.kt") public void testStepToSmallerLastThenStepOne() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep/stepToSmallerLastThenStepOne.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") public void testStepToSmallerLastThenStepToSameLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); } + @Test @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Reversed extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Reversed { + @Test public void testAllFilesPresentInReversed() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("reversedThenStep.kt") public void testReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed/reversedThenStep.kt"); } + @Test @TestMetadata("reversedThenStepThenReversed.kt") public void testReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed/reversedThenStepThenReversed.kt"); } + @Test @TestMetadata("reversedThenStepThenReversedThenStep.kt") public void testReversedThenStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed/reversedThenStepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversed.kt") public void testStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed/stepThenReversed.kt"); } + @Test @TestMetadata("stepThenReversedThenStep.kt") public void testStepThenReversedThenStep() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed/stepThenReversedThenStep.kt"); } + @Test @TestMetadata("stepThenReversedThenStepThenReversed.kt") public void testStepThenReversedThenStepThenReversed() throws Exception { runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed/stepThenReversedThenStepThenReversed.kt"); @@ -28246,406 +31633,465 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/unsigned") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Unsigned extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Unsigned { + @Test public void testAllFilesPresentInUnsigned() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("bitShifting.kt") public void testBitShifting() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/bitShifting.kt"); } + @Test @TestMetadata("inMixedUnsignedRange.kt") public void testInMixedUnsignedRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/inMixedUnsignedRange.kt"); } + @Test @TestMetadata("kt35004.kt") public void testKt35004() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/kt35004.kt"); } + @Test @TestMetadata("kt36953.kt") public void testKt36953() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/kt36953.kt"); } + @Test @TestMetadata("kt36953_continue.kt") public void testKt36953_continue() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/kt36953_continue.kt"); } + @Test @TestMetadata("outOfBoundsInMixedContains.kt") public void testOutOfBoundsInMixedContains() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/outOfBoundsInMixedContains.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/unsigned/expression") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Expression extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Expression { + @Test public void testAllFilesPresentInExpression() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/expression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("emptyDownto.kt") public void testEmptyDownto() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/emptyDownto.kt"); } + @Test @TestMetadata("emptyRange.kt") public void testEmptyRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/emptyRange.kt"); } + @Test @TestMetadata("inexactDownToMinValue.kt") public void testInexactDownToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/inexactDownToMinValue.kt"); } + @Test @TestMetadata("inexactSteppedDownTo.kt") public void testInexactSteppedDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/inexactSteppedDownTo.kt"); } + @Test @TestMetadata("inexactSteppedRange.kt") public void testInexactSteppedRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/inexactSteppedRange.kt"); } + @Test @TestMetadata("inexactToMaxValue.kt") public void testInexactToMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/inexactToMaxValue.kt"); } + @Test @TestMetadata("maxValueMinusTwoToMaxValue.kt") public void testMaxValueMinusTwoToMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/maxValueMinusTwoToMaxValue.kt"); } + @Test @TestMetadata("maxValueToMaxValue.kt") public void testMaxValueToMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/maxValueToMaxValue.kt"); } + @Test @TestMetadata("maxValueToMinValue.kt") public void testMaxValueToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/maxValueToMinValue.kt"); } + @Test @TestMetadata("oneElementDownTo.kt") public void testOneElementDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/oneElementDownTo.kt"); } + @Test @TestMetadata("oneElementRange.kt") public void testOneElementRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/oneElementRange.kt"); } + @Test @TestMetadata("openRange.kt") public void testOpenRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/openRange.kt"); } + @Test @TestMetadata("openRangeUntil.kt") public void testOpenRangeUntil() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/openRangeUntil.kt"); } + @Test @TestMetadata("overflowZeroDownToMaxValue.kt") public void testOverflowZeroDownToMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/overflowZeroDownToMaxValue.kt"); } + @Test @TestMetadata("overflowZeroToMinValue.kt") public void testOverflowZeroToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/overflowZeroToMinValue.kt"); } + @Test @TestMetadata("progressionDownToMinValue.kt") public void testProgressionDownToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/progressionDownToMinValue.kt"); } + @Test @TestMetadata("progressionMaxValueMinusTwoToMaxValue.kt") public void testProgressionMaxValueMinusTwoToMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/progressionMaxValueMinusTwoToMaxValue.kt"); } + @Test @TestMetadata("progressionMaxValueToMaxValue.kt") public void testProgressionMaxValueToMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/progressionMaxValueToMaxValue.kt"); } + @Test @TestMetadata("progressionMaxValueToMinValue.kt") public void testProgressionMaxValueToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/progressionMaxValueToMinValue.kt"); } + @Test @TestMetadata("progressionMinValueToMinValue.kt") public void testProgressionMinValueToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/progressionMinValueToMinValue.kt"); } + @Test @TestMetadata("reversedBackSequence.kt") public void testReversedBackSequence() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/reversedBackSequence.kt"); } + @Test @TestMetadata("reversedEmptyBackSequence.kt") public void testReversedEmptyBackSequence() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/reversedEmptyBackSequence.kt"); } + @Test @TestMetadata("reversedEmptyRange.kt") public void testReversedEmptyRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/reversedEmptyRange.kt"); } + @Test @TestMetadata("reversedInexactSteppedDownTo.kt") public void testReversedInexactSteppedDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/reversedInexactSteppedDownTo.kt"); } + @Test @TestMetadata("reversedRange.kt") public void testReversedRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/reversedRange.kt"); } + @Test @TestMetadata("reversedSimpleSteppedRange.kt") public void testReversedSimpleSteppedRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/reversedSimpleSteppedRange.kt"); } + @Test @TestMetadata("simpleDownTo.kt") public void testSimpleDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/simpleDownTo.kt"); } + @Test @TestMetadata("simpleRange.kt") public void testSimpleRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/simpleRange.kt"); } + @Test @TestMetadata("simpleRangeWithNonConstantEnds.kt") public void testSimpleRangeWithNonConstantEnds() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/simpleRangeWithNonConstantEnds.kt"); } + @Test @TestMetadata("simpleSteppedDownTo.kt") public void testSimpleSteppedDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/simpleSteppedDownTo.kt"); } + @Test @TestMetadata("simpleSteppedRange.kt") public void testSimpleSteppedRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/expression/simpleSteppedRange.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/unsigned/literal") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Literal extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Literal { + @Test public void testAllFilesPresentInLiteral() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/literal"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("emptyDownto.kt") public void testEmptyDownto() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/emptyDownto.kt"); } + @Test @TestMetadata("emptyRange.kt") public void testEmptyRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/emptyRange.kt"); } + @Test @TestMetadata("inexactDownToMinValue.kt") public void testInexactDownToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/inexactDownToMinValue.kt"); } + @Test @TestMetadata("inexactSteppedDownTo.kt") public void testInexactSteppedDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/inexactSteppedDownTo.kt"); } + @Test @TestMetadata("inexactSteppedRange.kt") public void testInexactSteppedRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/inexactSteppedRange.kt"); } + @Test @TestMetadata("inexactToMaxValue.kt") public void testInexactToMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/inexactToMaxValue.kt"); } + @Test @TestMetadata("maxValueMinusTwoToMaxValue.kt") public void testMaxValueMinusTwoToMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/maxValueMinusTwoToMaxValue.kt"); } + @Test @TestMetadata("maxValueToMaxValue.kt") public void testMaxValueToMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/maxValueToMaxValue.kt"); } + @Test @TestMetadata("maxValueToMinValue.kt") public void testMaxValueToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/maxValueToMinValue.kt"); } + @Test @TestMetadata("oneElementDownTo.kt") public void testOneElementDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/oneElementDownTo.kt"); } + @Test @TestMetadata("oneElementRange.kt") public void testOneElementRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/oneElementRange.kt"); } + @Test @TestMetadata("openRange.kt") public void testOpenRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/openRange.kt"); } + @Test @TestMetadata("openRangeUntil.kt") public void testOpenRangeUntil() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/openRangeUntil.kt"); } + @Test @TestMetadata("overflowZeroDownToMaxValue.kt") public void testOverflowZeroDownToMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/overflowZeroDownToMaxValue.kt"); } + @Test @TestMetadata("overflowZeroToMinValue.kt") public void testOverflowZeroToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/overflowZeroToMinValue.kt"); } + @Test @TestMetadata("progressionDownToMinValue.kt") public void testProgressionDownToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/progressionDownToMinValue.kt"); } + @Test @TestMetadata("progressionMaxValueMinusTwoToMaxValue.kt") public void testProgressionMaxValueMinusTwoToMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/progressionMaxValueMinusTwoToMaxValue.kt"); } + @Test @TestMetadata("progressionMaxValueToMaxValue.kt") public void testProgressionMaxValueToMaxValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/progressionMaxValueToMaxValue.kt"); } + @Test @TestMetadata("progressionMaxValueToMinValue.kt") public void testProgressionMaxValueToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/progressionMaxValueToMinValue.kt"); } + @Test @TestMetadata("progressionMinValueToMinValue.kt") public void testProgressionMinValueToMinValue() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/progressionMinValueToMinValue.kt"); } + @Test @TestMetadata("reversedBackSequence.kt") public void testReversedBackSequence() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/reversedBackSequence.kt"); } + @Test @TestMetadata("reversedEmptyBackSequence.kt") public void testReversedEmptyBackSequence() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/reversedEmptyBackSequence.kt"); } + @Test @TestMetadata("reversedEmptyRange.kt") public void testReversedEmptyRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/reversedEmptyRange.kt"); } + @Test @TestMetadata("reversedInexactSteppedDownTo.kt") public void testReversedInexactSteppedDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/reversedInexactSteppedDownTo.kt"); } + @Test @TestMetadata("reversedRange.kt") public void testReversedRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/reversedRange.kt"); } + @Test @TestMetadata("reversedSimpleSteppedRange.kt") public void testReversedSimpleSteppedRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/reversedSimpleSteppedRange.kt"); } + @Test @TestMetadata("simpleDownTo.kt") public void testSimpleDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/simpleDownTo.kt"); } + @Test @TestMetadata("simpleRange.kt") public void testSimpleRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/simpleRange.kt"); } + @Test @TestMetadata("simpleRangeWithNonConstantEnds.kt") public void testSimpleRangeWithNonConstantEnds() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/simpleRangeWithNonConstantEnds.kt"); } + @Test @TestMetadata("simpleSteppedDownTo.kt") public void testSimpleSteppedDownTo() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/simpleSteppedDownTo.kt"); } + @Test @TestMetadata("simpleSteppedRange.kt") public void testSimpleSteppedRange() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/literal/simpleSteppedRange.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NullableLoopParameter extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NullableLoopParameter { + @Test public void testAllFilesPresentInNullableLoopParameter() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("progressionExpression.kt") public void testProgressionExpression() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter/progressionExpression.kt"); } + @Test @TestMetadata("rangeExpression.kt") public void testRangeExpression() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter/rangeExpression.kt"); } + @Test @TestMetadata("rangeLiteral.kt") public void testRangeLiteral() throws Exception { runTest("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter/rangeLiteral.kt"); @@ -28654,523 +32100,432 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/recursiveRawTypes") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class RecursiveRawTypes extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class RecursiveRawTypes { + @Test public void testAllFilesPresentInRecursiveRawTypes() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/recursiveRawTypes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Reflection extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Reflection { + @Test public void testAllFilesPresentInReflection() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/annotations") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Annotations extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Annotations { + @Test public void testAllFilesPresentInAnnotations() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/annotations/onTypes") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class OnTypes extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class OnTypes { + @Test public void testAllFilesPresentInOnTypes() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations/onTypes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/annotations/repeatable") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Repeatable extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Repeatable { + @Test public void testAllFilesPresentInRepeatable() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations/repeatable"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/builtins") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Builtins extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Builtins { + @Test public void testAllFilesPresentInBuiltins() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/builtins"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/call") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Call extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Call { + @Test public void testAllFilesPresentInCall() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/call/bound") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Bound extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Bound { + @Test public void testAllFilesPresentInBound() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/bound"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/call/inlineClasses") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class InlineClasses extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class InlineClasses { + @Test public void testAllFilesPresentInInlineClasses() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/inlineClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/call/inlineClasses/nonNullObject") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NonNullObject extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NonNullObject { + @Test public void testAllFilesPresentInNonNullObject() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/inlineClasses/nonNullObject"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/call/inlineClasses/nullableObject") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NullableObject extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NullableObject { + @Test public void testAllFilesPresentInNullableObject() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/inlineClasses/nullableObject"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/call/inlineClasses/primitive") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Primitive extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Primitive { + @Test public void testAllFilesPresentInPrimitive() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/inlineClasses/primitive"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/call/valueClasses") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ValueClasses extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ValueClasses { + @Test public void testAllFilesPresentInValueClasses() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/valueClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/callBy") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class CallBy extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class CallBy { + @Test public void testAllFilesPresentInCallBy() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/callBy"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/classLiterals") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ClassLiterals extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ClassLiterals { + @Test public void testAllFilesPresentInClassLiterals() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classLiterals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("annotationClassLiteral.kt") public void testAnnotationClassLiteral() throws Exception { runTest("compiler/testData/codegen/box/reflection/classLiterals/annotationClassLiteral.kt"); } + @Test @TestMetadata("genericClass.kt") public void testGenericClass() throws Exception { runTest("compiler/testData/codegen/box/reflection/classLiterals/genericClass.kt"); } + @Test @TestMetadata("lambdaClass.kt") public void testLambdaClass() throws Exception { runTest("compiler/testData/codegen/box/reflection/classLiterals/lambdaClass.kt"); } + @Test @TestMetadata("simpleClassLiteral.kt") public void testSimpleClassLiteral() throws Exception { runTest("compiler/testData/codegen/box/reflection/classLiterals/simpleClassLiteral.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/classes") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Classes extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Classes { + @Test public void testAllFilesPresentInClasses() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("localClassSimpleName.kt") public void testLocalClassSimpleName() throws Exception { runTest("compiler/testData/codegen/box/reflection/classes/localClassSimpleName.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/constructors") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Constructors extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Constructors { + @Test public void testAllFilesPresentInConstructors() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/constructors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("constructorName.kt") public void testConstructorName() throws Exception { runTest("compiler/testData/codegen/box/reflection/constructors/constructorName.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/createAnnotation") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class CreateAnnotation extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class CreateAnnotation { + @Test public void testAllFilesPresentInCreateAnnotation() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/createAnnotation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/enclosing") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Enclosing extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Enclosing { + @Test public void testAllFilesPresentInEnclosing() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/enclosing"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/functions") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Functions extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Functions { + @Test public void testAllFilesPresentInFunctions() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/functions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("genericOverriddenFunction.kt") public void testGenericOverriddenFunction() throws Exception { runTest("compiler/testData/codegen/box/reflection/functions/genericOverriddenFunction.kt"); } + @Test @TestMetadata("simpleNames.kt") public void testSimpleNames() throws Exception { runTest("compiler/testData/codegen/box/reflection/functions/simpleNames.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/genericSignature") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class GenericSignature extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class GenericSignature { + @Test public void testAllFilesPresentInGenericSignature() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/genericSignature"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/isInstance") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class IsInstance extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class IsInstance { + @Test public void testAllFilesPresentInIsInstance() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/isInstance"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/kClassInAnnotation") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class KClassInAnnotation extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class KClassInAnnotation { + @Test public void testAllFilesPresentInKClassInAnnotation() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/kClassInAnnotation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/lambdaClasses") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class LambdaClasses extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class LambdaClasses { + @Test public void testAllFilesPresentInLambdaClasses() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/lambdaClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/mapping") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Mapping extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Mapping { + @Test public void testAllFilesPresentInMapping() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/mapping/fakeOverrides") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class FakeOverrides extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class FakeOverrides { + @Test public void testAllFilesPresentInFakeOverrides() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/fakeOverrides"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/mapping/inlineClasses") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class InlineClasses extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class InlineClasses { + @Test public void testAllFilesPresentInInlineClasses() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/inlineClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/mapping/jvmStatic") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class JvmStatic extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class JvmStatic { + @Test public void testAllFilesPresentInJvmStatic() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/jvmStatic"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/mapping/types") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Types extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Types { + @Test public void testAllFilesPresentInTypes() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/types"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/mapping/valueClasses") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ValueClasses extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ValueClasses { + @Test public void testAllFilesPresentInValueClasses() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/valueClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/methodsFromAny") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class MethodsFromAny extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class MethodsFromAny { + @Test public void testAllFilesPresentInMethodsFromAny() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/methodsFromAny"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("functionEqualsHashCode.kt") public void testFunctionEqualsHashCode() throws Exception { runTest("compiler/testData/codegen/box/reflection/methodsFromAny/functionEqualsHashCode.kt"); } + @Test @TestMetadata("propertyEqualsHashCode.kt") public void testPropertyEqualsHashCode() throws Exception { runTest("compiler/testData/codegen/box/reflection/methodsFromAny/propertyEqualsHashCode.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/modifiers") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Modifiers extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Modifiers { + @Test public void testAllFilesPresentInModifiers() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/modifiers"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/multifileClasses") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class MultifileClasses extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class MultifileClasses { + @Test public void testAllFilesPresentInMultifileClasses() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/multifileClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/noReflectAtRuntime") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NoReflectAtRuntime extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NoReflectAtRuntime { + @Test public void testAllFilesPresentInNoReflectAtRuntime() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("propertyGetSetName.kt") public void testPropertyGetSetName() throws Exception { runTest("compiler/testData/codegen/box/reflection/noReflectAtRuntime/propertyGetSetName.kt"); } + @Test @TestMetadata("propertyInstanceof.kt") public void testPropertyInstanceof() throws Exception { runTest("compiler/testData/codegen/box/reflection/noReflectAtRuntime/propertyInstanceof.kt"); } + @Test @TestMetadata("simpleClassLiterals.kt") public void testSimpleClassLiterals() throws Exception { runTest("compiler/testData/codegen/box/reflection/noReflectAtRuntime/simpleClassLiterals.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/noReflectAtRuntime/methodsFromAny") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class MethodsFromAny extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class MethodsFromAny { + @Test public void testAllFilesPresentInMethodsFromAny() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime/methodsFromAny"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("delegatedProperty.kt") public void testDelegatedProperty() throws Exception { runTest("compiler/testData/codegen/box/reflection/noReflectAtRuntime/methodsFromAny/delegatedProperty.kt"); @@ -29178,273 +32533,255 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/parameters") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Parameters extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Parameters { + @Test public void testAllFilesPresentInParameters() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/parameters"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/properties") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Properties extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Properties { + @Test public void testAllFilesPresentInProperties() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("genericOverriddenProperty.kt") public void testGenericOverriddenProperty() throws Exception { runTest("compiler/testData/codegen/box/reflection/properties/genericOverriddenProperty.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/properties/accessors") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Accessors extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Accessors { + @Test public void testAllFilesPresentInAccessors() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/accessors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/properties/getDelegate") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class GetDelegate extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class GetDelegate { + @Test public void testAllFilesPresentInGetDelegate() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/getDelegate"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/properties/getDelegate/method") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Method extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Method { + @Test public void testAllFilesPresentInMethod() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/getDelegate/method"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/properties/jvmField") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class JvmField extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class JvmField { + @Test public void testAllFilesPresentInJvmField() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/jvmField"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/properties/localDelegated") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class LocalDelegated extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class LocalDelegated { + @Test public void testAllFilesPresentInLocalDelegated() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/localDelegated"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/supertypes") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Supertypes extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Supertypes { + @Test public void testAllFilesPresentInSupertypes() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/supertypes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/typeOf") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TypeOf extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class TypeOf { + @Test public void testAllFilesPresentInTypeOf() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("arrayOfNullableReified.kt") public void testArrayOfNullableReified() throws Exception { runTest("compiler/testData/codegen/box/reflection/typeOf/arrayOfNullableReified.kt"); } + @Test @TestMetadata("classes.kt") public void testClasses() throws Exception { runTest("compiler/testData/codegen/box/reflection/typeOf/classes.kt"); } + @Test @TestMetadata("inlineClasses.kt") public void testInlineClasses() throws Exception { runTest("compiler/testData/codegen/box/reflection/typeOf/inlineClasses.kt"); } + @Test @TestMetadata("intersectionType.kt") public void testIntersectionType() throws Exception { runTest("compiler/testData/codegen/box/reflection/typeOf/intersectionType.kt"); } + @Test @TestMetadata("manyTypeArguments.kt") public void testManyTypeArguments() throws Exception { runTest("compiler/testData/codegen/box/reflection/typeOf/manyTypeArguments.kt"); } + @Test @TestMetadata("multipleLayers.kt") public void testMultipleLayers() throws Exception { runTest("compiler/testData/codegen/box/reflection/typeOf/multipleLayers.kt"); } + @Test @TestMetadata("reifiedAsNestedArgument.kt") public void testReifiedAsNestedArgument() throws Exception { runTest("compiler/testData/codegen/box/reflection/typeOf/reifiedAsNestedArgument.kt"); } + @Test @TestMetadata("typeOfCapturedStar.kt") public void testTypeOfCapturedStar() throws Exception { runTest("compiler/testData/codegen/box/reflection/typeOf/typeOfCapturedStar.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/typeOf/js") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Js extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Js { + @Test public void testAllFilesPresentInJs() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/js"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/typeOf/noReflect") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NoReflect extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NoReflect { + @Test public void testAllFilesPresentInNoReflect() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("typeReferenceEqualsHashCode.kt") public void testTypeReferenceEqualsHashCode() throws Exception { runTest("compiler/testData/codegen/box/reflection/typeOf/noReflect/typeReferenceEqualsHashCode.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/typeOf/noReflect/nonReifiedTypeParameters") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NonReifiedTypeParameters extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NonReifiedTypeParameters { + @Test public void testAllFilesPresentInNonReifiedTypeParameters() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect/nonReifiedTypeParameters"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class NonReifiedTypeParameters extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class NonReifiedTypeParameters { + @Test public void testAllFilesPresentInNonReifiedTypeParameters() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("defaultUpperBound.kt") public void testDefaultUpperBound() throws Exception { runTest("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters/defaultUpperBound.kt"); } + @Test @TestMetadata("equalsOnClassParameters.kt") public void testEqualsOnClassParameters() throws Exception { runTest("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters/equalsOnClassParameters.kt"); } + @Test @TestMetadata("equalsOnFunctionParameters.kt") public void testEqualsOnFunctionParameters() throws Exception { runTest("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters/equalsOnFunctionParameters.kt"); } + @Test @TestMetadata("innerGeneric.kt") public void testInnerGeneric() throws Exception { runTest("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters/innerGeneric.kt"); } + @Test @TestMetadata("simpleClassParameter.kt") public void testSimpleClassParameter() throws Exception { runTest("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters/simpleClassParameter.kt"); } + @Test @TestMetadata("simpleFunctionParameter.kt") public void testSimpleFunctionParameter() throws Exception { runTest("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters/simpleFunctionParameter.kt"); } + @Test @TestMetadata("simplePropertyParameter.kt") public void testSimplePropertyParameter() throws Exception { runTest("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters/simplePropertyParameter.kt"); } + @Test @TestMetadata("starProjectionInUpperBound.kt") public void testStarProjectionInUpperBound() throws Exception { runTest("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters/starProjectionInUpperBound.kt"); } + @Test @TestMetadata("typeParameterFlags.kt") public void testTypeParameterFlags() throws Exception { runTest("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters/typeParameterFlags.kt"); } + @Test @TestMetadata("upperBoundUsesOuterClassParameter.kt") public void testUpperBoundUsesOuterClassParameter() throws Exception { runTest("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters/upperBoundUsesOuterClassParameter.kt"); } + @Test @TestMetadata("upperBounds.kt") public void testUpperBounds() throws Exception { runTest("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters/upperBounds.kt"); @@ -29452,67 +32789,58 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/typeParameters") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TypeParameters extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class TypeParameters { + @Test public void testAllFilesPresentInTypeParameters() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeParameters"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/types") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Types extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Types { + @Test public void testAllFilesPresentInTypes() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("innerGenericArguments.kt") public void testInnerGenericArguments() throws Exception { runTest("compiler/testData/codegen/box/reflection/types/innerGenericArguments.kt"); } + @Test @TestMetadata("typeArguments.kt") public void testTypeArguments() throws Exception { runTest("compiler/testData/codegen/box/reflection/types/typeArguments.kt"); } + @Test @TestMetadata("useSiteVariance.kt") public void testUseSiteVariance() throws Exception { runTest("compiler/testData/codegen/box/reflection/types/useSiteVariance.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/types/createType") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class CreateType extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class CreateType { + @Test public void testAllFilesPresentInCreateType() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/createType"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reflection/types/subtyping") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Subtyping extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Subtyping { + @Test public void testAllFilesPresentInSubtyping() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/subtyping"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } @@ -29520,493 +32848,581 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/regressions") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Regressions extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Regressions { + @Test public void testAllFilesPresentInRegressions() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/regressions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("arrayLengthNPE.kt") public void testArrayLengthNPE() throws Exception { runTest("compiler/testData/codegen/box/regressions/arrayLengthNPE.kt"); } + @Test @TestMetadata("commonSupertypeContravariant.kt") public void testCommonSupertypeContravariant() throws Exception { runTest("compiler/testData/codegen/box/regressions/commonSupertypeContravariant.kt"); } + @Test @TestMetadata("commonSupertypeContravariant2.kt") public void testCommonSupertypeContravariant2() throws Exception { runTest("compiler/testData/codegen/box/regressions/commonSupertypeContravariant2.kt"); } + @Test @TestMetadata("dontCaptureTypesWithTypeVariables.kt") public void testDontCaptureTypesWithTypeVariables() throws Exception { runTest("compiler/testData/codegen/box/regressions/dontCaptureTypesWithTypeVariables.kt"); } + @Test @TestMetadata("doubleMerge.kt") public void testDoubleMerge() throws Exception { runTest("compiler/testData/codegen/box/regressions/doubleMerge.kt"); } + @Test @TestMetadata("floatMerge.kt") public void testFloatMerge() throws Exception { runTest("compiler/testData/codegen/box/regressions/floatMerge.kt"); } + @Test @TestMetadata("functionLiteralAsLastExpressionInBlock.kt") public void testFunctionLiteralAsLastExpressionInBlock() throws Exception { runTest("compiler/testData/codegen/box/regressions/functionLiteralAsLastExpressionInBlock.kt"); } + @Test @TestMetadata("generic.kt") public void testGeneric() throws Exception { runTest("compiler/testData/codegen/box/regressions/generic.kt"); } + @Test @TestMetadata("hashCodeNPE.kt") public void testHashCodeNPE() throws Exception { runTest("compiler/testData/codegen/box/regressions/hashCodeNPE.kt"); } + @Test @TestMetadata("internalTopLevelOtherPackage.kt") public void testInternalTopLevelOtherPackage() throws Exception { runTest("compiler/testData/codegen/box/regressions/internalTopLevelOtherPackage.kt"); } + @Test @TestMetadata("intersectionOfEqualTypes.kt") public void testIntersectionOfEqualTypes() throws Exception { runTest("compiler/testData/codegen/box/regressions/intersectionOfEqualTypes.kt"); } + @Test @TestMetadata("kt10143.kt") public void testKt10143() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt10143.kt"); } + @Test @TestMetadata("kt10934.kt") public void testKt10934() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt10934.kt"); } + @Test @TestMetadata("Kt1149.kt") public void testKt1149() throws Exception { runTest("compiler/testData/codegen/box/regressions/Kt1149.kt"); } + @Test + @TestMetadata("kt1172.kt") + public void testKt1172() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt1172.kt"); + } + + @Test @TestMetadata("kt13381.kt") public void testKt13381() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt13381.kt"); } + @Test @TestMetadata("kt14447.kt") public void testKt14447() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt14447.kt"); } + @Test @TestMetadata("kt15196.kt") public void testKt15196() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt15196.kt"); } + @Test @TestMetadata("kt1528.kt") public void testKt1528() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt1528.kt"); } + @Test @TestMetadata("Kt1619Test.kt") public void testKt1619Test() throws Exception { runTest("compiler/testData/codegen/box/regressions/Kt1619Test.kt"); } + @Test @TestMetadata("kt1779.kt") public void testKt1779() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt1779.kt"); } + @Test @TestMetadata("kt1800.kt") public void testKt1800() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt1800.kt"); } + @Test @TestMetadata("kt1845.kt") public void testKt1845() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt1845.kt"); } + @Test @TestMetadata("kt18779.kt") public void testKt18779() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt18779.kt"); } + @Test @TestMetadata("kt2017.kt") public void testKt2017() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt2017.kt"); } + @Test @TestMetadata("kt2060.kt") public void testKt2060() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt2060.kt"); } + @Test @TestMetadata("kt2210.kt") public void testKt2210() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt2210.kt"); } + @Test @TestMetadata("kt2246.kt") public void testKt2246() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt2246.kt"); } + @Test @TestMetadata("kt24913.kt") public void testKt24913() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt24913.kt"); } + @Test @TestMetadata("Kt2495Test.kt") public void testKt2495Test() throws Exception { runTest("compiler/testData/codegen/box/regressions/Kt2495Test.kt"); } + @Test @TestMetadata("kt2509.kt") public void testKt2509() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt2509.kt"); } + @Test @TestMetadata("kt3107.kt") public void testKt3107() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt3107.kt"); } + @Test @TestMetadata("kt32949.kt") public void testKt32949() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt32949.kt"); } + @Test @TestMetadata("kt33638.kt") public void testKt33638() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt33638.kt"); } + @Test @TestMetadata("kt3421.kt") public void testKt3421() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt3421.kt"); } + @Test @TestMetadata("kt344.kt") public void testKt344() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt344.kt"); } + @Test @TestMetadata("kt3442.kt") public void testKt3442() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt3442.kt"); } + @Test @TestMetadata("kt3587.kt") public void testKt3587() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt3587.kt"); } + @Test @TestMetadata("kt35914.kt") public void testKt35914() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt35914.kt"); } + @Test @TestMetadata("kt3850.kt") public void testKt3850() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt3850.kt"); } + @Test @TestMetadata("kt3903.kt") public void testKt3903() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt3903.kt"); } + @Test @TestMetadata("kt39088.kt") public void testKt39088() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt39088.kt"); } + @Test @TestMetadata("kt4142.kt") public void testKt4142() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt4142.kt"); } + @Test @TestMetadata("kt4281.kt") public void testKt4281() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt4281.kt"); } + @Test @TestMetadata("kt47279.kt") public void testKt47279() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt47279.kt"); } + @Test @TestMetadata("kt5056.kt") public void testKt5056() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt5056.kt"); } + @Test @TestMetadata("kt5395.kt") public void testKt5395() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt5395.kt"); } + @Test @TestMetadata("kt57487.kt") public void testKt57487() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt57487.kt"); } + @Test @TestMetadata("kt5786_privateWithDefault.kt") public void testKt5786_privateWithDefault() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt5786_privateWithDefault.kt"); } + @Test @TestMetadata("kt5953.kt") public void testKt5953() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt5953.kt"); } + @Test @TestMetadata("kt6153.kt") public void testKt6153() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt6153.kt"); } + @Test @TestMetadata("kt6434.kt") public void testKt6434() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt6434.kt"); } + @Test @TestMetadata("kt6434_2.kt") public void testKt6434_2() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt6434_2.kt"); } + @Test @TestMetadata("kt7401.kt") public void testKt7401() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt7401.kt"); } + @Test @TestMetadata("kt789.kt") public void testKt789() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt789.kt"); } + @Test @TestMetadata("kt998.kt") public void testKt998() throws Exception { runTest("compiler/testData/codegen/box/regressions/kt998.kt"); } + @Test @TestMetadata("lambdaAsLastExpressionInLambda.kt") public void testLambdaAsLastExpressionInLambda() throws Exception { runTest("compiler/testData/codegen/box/regressions/lambdaAsLastExpressionInLambda.kt"); } + @Test @TestMetadata("lambdaPostponeConstruction.kt") public void testLambdaPostponeConstruction() throws Exception { runTest("compiler/testData/codegen/box/regressions/lambdaPostponeConstruction.kt"); } + @Test @TestMetadata("lambdaWrongReturnType.kt") public void testLambdaWrongReturnType() throws Exception { runTest("compiler/testData/codegen/box/regressions/lambdaWrongReturnType.kt"); } + @Test @TestMetadata("noAssertionsWhenNullableTypeParameterReplacedWithIntersectionType.kt") public void testNoAssertionsWhenNullableTypeParameterReplacedWithIntersectionType() throws Exception { runTest("compiler/testData/codegen/box/regressions/noAssertionsWhenNullableTypeParameterReplacedWithIntersectionType.kt"); } + @Test @TestMetadata("noCapturingForTypesWithTypeVariables.kt") public void testNoCapturingForTypesWithTypeVariables() throws Exception { runTest("compiler/testData/codegen/box/regressions/noCapturingForTypesWithTypeVariables.kt"); } + @Test @TestMetadata("noResolutionRecursion.kt") public void testNoResolutionRecursion() throws Exception { runTest("compiler/testData/codegen/box/regressions/noResolutionRecursion.kt"); } + @Test @TestMetadata("nullabilityForCommonCapturedSupertypes.kt") public void testNullabilityForCommonCapturedSupertypes() throws Exception { runTest("compiler/testData/codegen/box/regressions/nullabilityForCommonCapturedSupertypes.kt"); } + @Test @TestMetadata("nullableAfterExclExcl.kt") public void testNullableAfterExclExcl() throws Exception { runTest("compiler/testData/codegen/box/regressions/nullableAfterExclExcl.kt"); } + @Test @TestMetadata("objectCaptureOuterConstructorProperty.kt") public void testObjectCaptureOuterConstructorProperty() throws Exception { runTest("compiler/testData/codegen/box/regressions/objectCaptureOuterConstructorProperty.kt"); } + @Test @TestMetadata("objectInsideDelegation.kt") public void testObjectInsideDelegation() throws Exception { runTest("compiler/testData/codegen/box/regressions/objectInsideDelegation.kt"); } + @Test @TestMetadata("recursiveDnnTypeInLambda.kt") public void testRecursiveDnnTypeInLambda() throws Exception { runTest("compiler/testData/codegen/box/regressions/recursiveDnnTypeInLambda.kt"); } + @Test @TestMetadata("resolvedCallForGetOperator.kt") public void testResolvedCallForGetOperator() throws Exception { runTest("compiler/testData/codegen/box/regressions/resolvedCallForGetOperator.kt"); } + @Test @TestMetadata("supertypeDepth.kt") public void testSupertypeDepth() throws Exception { runTest("compiler/testData/codegen/box/regressions/supertypeDepth.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/reified") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Reified extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Reified { + @Test public void testAllFilesPresentInReified() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("callableReferenceInlinedFun.kt") public void testCallableReferenceInlinedFun() throws Exception { runTest("compiler/testData/codegen/box/reified/callableReferenceInlinedFun.kt"); } + @Test @TestMetadata("callableReferenceInlinedFunFromOtherModule.kt") public void testCallableReferenceInlinedFunFromOtherModule() throws Exception { runTest("compiler/testData/codegen/box/reified/callableReferenceInlinedFunFromOtherModule.kt"); } + @Test @TestMetadata("checkcast.kt") public void testCheckcast() throws Exception { runTest("compiler/testData/codegen/box/reified/checkcast.kt"); } + @Test @TestMetadata("copyToArray.kt") public void testCopyToArray() throws Exception { runTest("compiler/testData/codegen/box/reified/copyToArray.kt"); } + @Test @TestMetadata("filterIsInstance.kt") public void testFilterIsInstance() throws Exception { runTest("compiler/testData/codegen/box/reified/filterIsInstance.kt"); } + @Test @TestMetadata("instanceof.kt") public void testInstanceof() throws Exception { runTest("compiler/testData/codegen/box/reified/instanceof.kt"); } + @Test @TestMetadata("kt16445.kt") public void testKt16445() throws Exception { runTest("compiler/testData/codegen/box/reified/kt16445.kt"); } + @Test @TestMetadata("kt36237.kt") public void testKt36237() throws Exception { runTest("compiler/testData/codegen/box/reified/kt36237.kt"); } + @Test @TestMetadata("kt39256_privateInlineWithAnonymousObject.kt") public void testKt39256_privateInlineWithAnonymousObject() throws Exception { runTest("compiler/testData/codegen/box/reified/kt39256_privateInlineWithAnonymousObject.kt"); } + @Test @TestMetadata("newArrayInt.kt") public void testNewArrayInt() throws Exception { runTest("compiler/testData/codegen/box/reified/newArrayInt.kt"); } + @Test @TestMetadata("recursiveNewArray.kt") public void testRecursiveNewArray() throws Exception { runTest("compiler/testData/codegen/box/reified/recursiveNewArray.kt"); } + @Test @TestMetadata("reifiedChain.kt") public void testReifiedChain() throws Exception { runTest("compiler/testData/codegen/box/reified/reifiedChain.kt"); } + @Test @TestMetadata("reifiedIntersectionType.kt") public void testReifiedIntersectionType() throws Exception { runTest("compiler/testData/codegen/box/reified/reifiedIntersectionType.kt"); } + @Test @TestMetadata("reifiedIntersectionTypeArgument.kt") public void testReifiedIntersectionTypeArgument() throws Exception { runTest("compiler/testData/codegen/box/reified/reifiedIntersectionTypeArgument.kt"); } + @Test @TestMetadata("reifiedIntersectionTypeArgumentCrossModule.kt") public void testReifiedIntersectionTypeArgumentCrossModule() throws Exception { runTest("compiler/testData/codegen/box/reified/reifiedIntersectionTypeArgumentCrossModule.kt"); } + @Test @TestMetadata("reifiedTypeArgumentWithIntersectionTypeAsTypeArgument.kt") public void testReifiedTypeArgumentWithIntersectionTypeAsTypeArgument() throws Exception { runTest("compiler/testData/codegen/box/reified/reifiedTypeArgumentWithIntersectionTypeAsTypeArgument.kt"); } + @Test @TestMetadata("reifiedTypeArgumentWithRecursion.kt") public void testReifiedTypeArgumentWithRecursion() throws Exception { runTest("compiler/testData/codegen/box/reified/reifiedTypeArgumentWithRecursion.kt"); } + @Test @TestMetadata("safecast.kt") public void testSafecast() throws Exception { runTest("compiler/testData/codegen/box/reified/safecast.kt"); } + @Test @TestMetadata("sameIndexRecursive.kt") public void testSameIndexRecursive() throws Exception { runTest("compiler/testData/codegen/box/reified/sameIndexRecursive.kt"); } + @Test @TestMetadata("spreads.kt") public void testSpreads() throws Exception { runTest("compiler/testData/codegen/box/reified/spreads.kt"); } + @Test @TestMetadata("varargs.kt") public void testVarargs() throws Exception { runTest("compiler/testData/codegen/box/reified/varargs.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/reified/arraysReification") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ArraysReification extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ArraysReification { + @Test public void testAllFilesPresentInArraysReification() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified/arraysReification"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("jaggedArray.kt") public void testJaggedArray() throws Exception { runTest("compiler/testData/codegen/box/reified/arraysReification/jaggedArray.kt"); } + @Test @TestMetadata("jaggedDeep.kt") public void testJaggedDeep() throws Exception { runTest("compiler/testData/codegen/box/reified/arraysReification/jaggedDeep.kt"); @@ -30014,1337 +33430,1493 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/safeCall") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SafeCall extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class SafeCall { + @Test public void testAllFilesPresentInSafeCall() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/safeCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("genericNull.kt") public void testGenericNull() throws Exception { runTest("compiler/testData/codegen/box/safeCall/genericNull.kt"); } + @Test @TestMetadata("kt1572.kt") public void testKt1572() throws Exception { runTest("compiler/testData/codegen/box/safeCall/kt1572.kt"); } + @Test @TestMetadata("kt232.kt") public void testKt232() throws Exception { runTest("compiler/testData/codegen/box/safeCall/kt232.kt"); } + @Test @TestMetadata("kt245.kt") public void testKt245() throws Exception { runTest("compiler/testData/codegen/box/safeCall/kt245.kt"); } + @Test @TestMetadata("kt247.kt") public void testKt247() throws Exception { runTest("compiler/testData/codegen/box/safeCall/kt247.kt"); } + @Test @TestMetadata("kt3430.kt") public void testKt3430() throws Exception { runTest("compiler/testData/codegen/box/safeCall/kt3430.kt"); } + @Test @TestMetadata("kt4733.kt") public void testKt4733() throws Exception { runTest("compiler/testData/codegen/box/safeCall/kt4733.kt"); } + @Test @TestMetadata("kt52580.kt") public void testKt52580() throws Exception { runTest("compiler/testData/codegen/box/safeCall/kt52580.kt"); } + @Test @TestMetadata("kt52743.kt") public void testKt52743() throws Exception { runTest("compiler/testData/codegen/box/safeCall/kt52743.kt"); } + @Test @TestMetadata("primitive.kt") public void testPrimitive() throws Exception { runTest("compiler/testData/codegen/box/safeCall/primitive.kt"); } + @Test @TestMetadata("primitiveEqSafeCall.kt") public void testPrimitiveEqSafeCall() throws Exception { runTest("compiler/testData/codegen/box/safeCall/primitiveEqSafeCall.kt"); } + @Test @TestMetadata("primitiveNotEqSafeCall.kt") public void testPrimitiveNotEqSafeCall() throws Exception { runTest("compiler/testData/codegen/box/safeCall/primitiveNotEqSafeCall.kt"); } + @Test @TestMetadata("safeCallEqPrimitive.kt") public void testSafeCallEqPrimitive() throws Exception { runTest("compiler/testData/codegen/box/safeCall/safeCallEqPrimitive.kt"); } + @Test @TestMetadata("safeCallIOnUninitializedNonNullValue.kt") public void testSafeCallIOnUninitializedNonNullValue() throws Exception { runTest("compiler/testData/codegen/box/safeCall/safeCallIOnUninitializedNonNullValue.kt"); } + @Test @TestMetadata("safeCallNotEqPrimitive.kt") public void testSafeCallNotEqPrimitive() throws Exception { runTest("compiler/testData/codegen/box/safeCall/safeCallNotEqPrimitive.kt"); } + @Test @TestMetadata("safeCallOnLong.kt") public void testSafeCallOnLong() throws Exception { runTest("compiler/testData/codegen/box/safeCall/safeCallOnLong.kt"); } + @Test @TestMetadata("safeCallWithElvisFolding.kt") public void testSafeCallWithElvisFolding() throws Exception { runTest("compiler/testData/codegen/box/safeCall/safeCallWithElvisFolding.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/sam") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Sam extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Sam { + @Test public void testAllFilesPresentInSam() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt51821.kt") public void testKt51821() throws Exception { runTest("compiler/testData/codegen/box/sam/kt51821.kt"); } + @Test @TestMetadata("kt56188.kt") public void testKt56188() throws Exception { runTest("compiler/testData/codegen/box/sam/kt56188.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/sam/adapters") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Adapters extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Adapters { + @Test public void testAllFilesPresentInAdapters() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/adapters"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/sam/adapters/operators") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Operators extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Operators { + @Test public void testAllFilesPresentInOperators() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/adapters/operators"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/sam/approximation") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Approximation extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Approximation { + @Test public void testAllFilesPresentInApproximation() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/approximation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("approxToIntermediateType.kt") public void testApproxToIntermediateType() throws Exception { runTest("compiler/testData/codegen/box/sam/approximation/approxToIntermediateType.kt"); } + @Test @TestMetadata("approxToSingleUpperBound.kt") public void testApproxToSingleUpperBound() throws Exception { runTest("compiler/testData/codegen/box/sam/approximation/approxToSingleUpperBound.kt"); } + @Test @TestMetadata("impossibleToApproxToRepresentable.kt") public void testImpossibleToApproxToRepresentable() throws Exception { runTest("compiler/testData/codegen/box/sam/approximation/impossibleToApproxToRepresentable.kt"); } + @Test @TestMetadata("impossibleToApproxToRepresentable2.kt") public void testImpossibleToApproxToRepresentable2() throws Exception { runTest("compiler/testData/codegen/box/sam/approximation/impossibleToApproxToRepresentable2.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/sam/constructors") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Constructors extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Constructors { + @Test public void testAllFilesPresentInConstructors() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/constructors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("comparator.kt") public void testComparator() throws Exception { runTest("compiler/testData/codegen/box/sam/constructors/comparator.kt"); } + @Test @TestMetadata("nonLiteralComparator.kt") public void testNonLiteralComparator() throws Exception { runTest("compiler/testData/codegen/box/sam/constructors/nonLiteralComparator.kt"); } + @Test @TestMetadata("sameWrapperClass2.kt") public void testSameWrapperClass2() throws Exception { runTest("compiler/testData/codegen/box/sam/constructors/sameWrapperClass2.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/sam/equality") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Equality extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Equality { + @Test public void testAllFilesPresentInEquality() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/equality"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/sam/javaSamWithEqualsHashCode") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class JavaSamWithEqualsHashCode extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class JavaSamWithEqualsHashCode { + @Test public void testAllFilesPresentInJavaSamWithEqualsHashCode() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/javaSamWithEqualsHashCode"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/sameFileInSourceAndDependencies") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SameFileInSourceAndDependencies extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class SameFileInSourceAndDependencies { + @Test public void testAllFilesPresentInSameFileInSourceAndDependencies() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sameFileInSourceAndDependencies"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("classDeclaration.kt") public void testClassDeclaration() throws Exception { runTest("compiler/testData/codegen/box/sameFileInSourceAndDependencies/classDeclaration.kt"); } + @Test @TestMetadata("differingNumberOfGenericTypeParameters.kt") public void testDifferingNumberOfGenericTypeParameters() throws Exception { runTest("compiler/testData/codegen/box/sameFileInSourceAndDependencies/differingNumberOfGenericTypeParameters.kt"); } + @Test @TestMetadata("functionDeclaration.kt") public void testFunctionDeclaration() throws Exception { runTest("compiler/testData/codegen/box/sameFileInSourceAndDependencies/functionDeclaration.kt"); } + @Test @TestMetadata("lateinitMemberPropertyDeclaration.kt") public void testLateinitMemberPropertyDeclaration() throws Exception { runTest("compiler/testData/codegen/box/sameFileInSourceAndDependencies/lateinitMemberPropertyDeclaration.kt"); } + @Test @TestMetadata("memberFunctionDeclaration.kt") public void testMemberFunctionDeclaration() throws Exception { runTest("compiler/testData/codegen/box/sameFileInSourceAndDependencies/memberFunctionDeclaration.kt"); } + @Test @TestMetadata("memberFunctionWithDefaultArgumentsDeclaration.kt") public void testMemberFunctionWithDefaultArgumentsDeclaration() throws Exception { runTest("compiler/testData/codegen/box/sameFileInSourceAndDependencies/memberFunctionWithDefaultArgumentsDeclaration.kt"); } + @Test @TestMetadata("memberPropertyDeclaration.kt") public void testMemberPropertyDeclaration() throws Exception { runTest("compiler/testData/codegen/box/sameFileInSourceAndDependencies/memberPropertyDeclaration.kt"); } + @Test @TestMetadata("nestedClassDeclaration.kt") public void testNestedClassDeclaration() throws Exception { runTest("compiler/testData/codegen/box/sameFileInSourceAndDependencies/nestedClassDeclaration.kt"); } + @Test @TestMetadata("propertyDeclaration.kt") public void testPropertyDeclaration() throws Exception { runTest("compiler/testData/codegen/box/sameFileInSourceAndDependencies/propertyDeclaration.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/script") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Script extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Script { + @Test public void testAllFilesPresentInScript() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/script"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/sealed") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Sealed extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Sealed { + @Test public void testAllFilesPresentInSealed() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sealed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("delegatingConstructor.kt") public void testDelegatingConstructor() throws Exception { runTest("compiler/testData/codegen/box/sealed/delegatingConstructor.kt"); } + @Test @TestMetadata("kt49752.kt") public void testKt49752() throws Exception { runTest("compiler/testData/codegen/box/sealed/kt49752.kt"); } + @Test @TestMetadata("kt54028.kt") public void testKt54028() throws Exception { runTest("compiler/testData/codegen/box/sealed/kt54028.kt"); } + @Test + @TestMetadata("kt54028_cursed.kt") + public void testKt54028_cursed() throws Exception { + runTest("compiler/testData/codegen/box/sealed/kt54028_cursed.kt"); + } + + @Test @TestMetadata("multipleFiles_enabled.kt") public void testMultipleFiles_enabled() throws Exception { runTest("compiler/testData/codegen/box/sealed/multipleFiles_enabled.kt"); } + @Test @TestMetadata("objects.kt") public void testObjects() throws Exception { runTest("compiler/testData/codegen/box/sealed/objects.kt"); } + @Test @TestMetadata("sealedInSameFile.kt") public void testSealedInSameFile() throws Exception { runTest("compiler/testData/codegen/box/sealed/sealedInSameFile.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/sealed/simple.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/secondaryConstructors") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SecondaryConstructors extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class SecondaryConstructors { + @Test @TestMetadata("accessToCompanion.kt") public void testAccessToCompanion() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/accessToCompanion.kt"); } + @Test @TestMetadata("accessToNestedObject.kt") public void testAccessToNestedObject() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/accessToNestedObject.kt"); } + @Test public void testAllFilesPresentInSecondaryConstructors() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/secondaryConstructors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("basicNoPrimaryManySinks.kt") public void testBasicNoPrimaryManySinks() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/basicNoPrimaryManySinks.kt"); } + @Test @TestMetadata("basicNoPrimaryOneSink.kt") public void testBasicNoPrimaryOneSink() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/basicNoPrimaryOneSink.kt"); } + @Test @TestMetadata("basicPrimary.kt") public void testBasicPrimary() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/basicPrimary.kt"); } + @Test @TestMetadata("callFromLocalSubClass.kt") public void testCallFromLocalSubClass() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/callFromLocalSubClass.kt"); } + @Test @TestMetadata("callFromPrimaryWithNamedArgs.kt") public void testCallFromPrimaryWithNamedArgs() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/callFromPrimaryWithNamedArgs.kt"); } + @Test @TestMetadata("callFromPrimaryWithOptionalArgs.kt") public void testCallFromPrimaryWithOptionalArgs() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/callFromPrimaryWithOptionalArgs.kt"); } + @Test @TestMetadata("callFromSubClass.kt") public void testCallFromSubClass() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/callFromSubClass.kt"); } + @Test @TestMetadata("clashingDefaultConstructors.kt") public void testClashingDefaultConstructors() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/clashingDefaultConstructors.kt"); } + @Test @TestMetadata("dataClasses.kt") public void testDataClasses() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/dataClasses.kt"); } + @Test @TestMetadata("defaultArgs.kt") public void testDefaultArgs() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/defaultArgs.kt"); } + @Test @TestMetadata("defaultParametersNotDuplicated.kt") public void testDefaultParametersNotDuplicated() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/defaultParametersNotDuplicated.kt"); } + @Test @TestMetadata("delegateWithComplexExpression.kt") public void testDelegateWithComplexExpression() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/delegateWithComplexExpression.kt"); } + @Test @TestMetadata("delegatedThisWithLambda.kt") public void testDelegatedThisWithLambda() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/delegatedThisWithLambda.kt"); } + @Test @TestMetadata("delegationWithPrimary.kt") public void testDelegationWithPrimary() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/delegationWithPrimary.kt"); } + @Test @TestMetadata("enums.kt") public void testEnums() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/enums.kt"); } + @Test @TestMetadata("fieldInitializerOptimization.kt") public void testFieldInitializerOptimization() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/fieldInitializerOptimization.kt"); } + @Test @TestMetadata("generics.kt") public void testGenerics() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/generics.kt"); } + @Test @TestMetadata("inlineIntoTwoConstructors.kt") public void testInlineIntoTwoConstructors() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/inlineIntoTwoConstructors.kt"); } + @Test @TestMetadata("innerClasses.kt") public void testInnerClasses() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/innerClasses.kt"); } + @Test @TestMetadata("innerClassesInheritance.kt") public void testInnerClassesInheritance() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/innerClassesInheritance.kt"); } + @Test @TestMetadata("localClasses.kt") public void testLocalClasses() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/localClasses.kt"); } + @Test @TestMetadata("superCallPrimary.kt") public void testSuperCallPrimary() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/superCallPrimary.kt"); } + @Test @TestMetadata("superCallSecondary.kt") public void testSuperCallSecondary() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/superCallSecondary.kt"); } + @Test @TestMetadata("varargs.kt") public void testVarargs() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/varargs.kt"); } + @Test @TestMetadata("withNonLocalReturn.kt") public void testWithNonLocalReturn() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/withNonLocalReturn.kt"); } + @Test @TestMetadata("withReturn.kt") public void testWithReturn() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/withReturn.kt"); } + @Test @TestMetadata("withReturnUnit.kt") public void testWithReturnUnit() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/withReturnUnit.kt"); } + @Test @TestMetadata("withoutPrimarySimple.kt") public void testWithoutPrimarySimple() throws Exception { runTest("compiler/testData/codegen/box/secondaryConstructors/withoutPrimarySimple.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/size") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Size extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Size { + @Test @TestMetadata("add.kt") public void testAdd() throws Exception { runTest("compiler/testData/codegen/box/size/add.kt"); } + @Test public void testAllFilesPresentInSize() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/size"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("helloWorld.kt") public void testHelloWorld() throws Exception { runTest("compiler/testData/codegen/box/size/helloWorld.kt"); } + @Test @TestMetadata("helloWorldDOM.kt") public void testHelloWorldDOM() throws Exception { runTest("compiler/testData/codegen/box/size/helloWorldDOM.kt"); } + @Test @TestMetadata("objectsOptimization.kt") public void testObjectsOptimization() throws Exception { runTest("compiler/testData/codegen/box/size/objectsOptimization.kt"); } + @Test @TestMetadata("ok.kt") public void testOk() throws Exception { runTest("compiler/testData/codegen/box/size/ok.kt"); } + @Test @TestMetadata("removeUnusedOverride.kt") public void testRemoveUnusedOverride() throws Exception { runTest("compiler/testData/codegen/box/size/removeUnusedOverride.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/smap") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Smap extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Smap { + @Test public void testAllFilesPresentInSmap() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smap"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/smartCasts") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SmartCasts extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class SmartCasts { + @Test public void testAllFilesPresentInSmartCasts() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smartCasts"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("avoidSmartCastToDerivedForPrivate.kt") public void testAvoidSmartCastToDerivedForPrivate() throws Exception { runTest("compiler/testData/codegen/box/smartCasts/avoidSmartCastToDerivedForPrivate.kt"); } + @Test @TestMetadata("complexExplicitReceiver.kt") public void testComplexExplicitReceiver() throws Exception { runTest("compiler/testData/codegen/box/smartCasts/complexExplicitReceiver.kt"); } + @Test @TestMetadata("complexImplicitReceiver.kt") public void testComplexImplicitReceiver() throws Exception { runTest("compiler/testData/codegen/box/smartCasts/complexImplicitReceiver.kt"); } + @Test @TestMetadata("falseSmartCast.kt") public void testFalseSmartCast() throws Exception { runTest("compiler/testData/codegen/box/smartCasts/falseSmartCast.kt"); } + @Test @TestMetadata("genericIntersection.kt") public void testGenericIntersection() throws Exception { runTest("compiler/testData/codegen/box/smartCasts/genericIntersection.kt"); } + @Test @TestMetadata("genericSet.kt") public void testGenericSet() throws Exception { runTest("compiler/testData/codegen/box/smartCasts/genericSet.kt"); } + @Test @TestMetadata("implicitExtensionReceiver.kt") public void testImplicitExtensionReceiver() throws Exception { runTest("compiler/testData/codegen/box/smartCasts/implicitExtensionReceiver.kt"); } + @Test @TestMetadata("implicitMemberReceiver.kt") public void testImplicitMemberReceiver() throws Exception { runTest("compiler/testData/codegen/box/smartCasts/implicitMemberReceiver.kt"); } + @Test @TestMetadata("implicitReceiver.kt") public void testImplicitReceiver() throws Exception { runTest("compiler/testData/codegen/box/smartCasts/implicitReceiver.kt"); } + @Test @TestMetadata("implicitReceiverInWhen.kt") public void testImplicitReceiverInWhen() throws Exception { runTest("compiler/testData/codegen/box/smartCasts/implicitReceiverInWhen.kt"); } + @Test @TestMetadata("implicitToGrandSon.kt") public void testImplicitToGrandSon() throws Exception { runTest("compiler/testData/codegen/box/smartCasts/implicitToGrandSon.kt"); } + @Test @TestMetadata("kt17725.kt") public void testKt17725() throws Exception { runTest("compiler/testData/codegen/box/smartCasts/kt17725.kt"); } + @Test @TestMetadata("kt19100.kt") public void testKt19100() throws Exception { runTest("compiler/testData/codegen/box/smartCasts/kt19100.kt"); } + @Test @TestMetadata("kt42517.kt") public void testKt42517() throws Exception { runTest("compiler/testData/codegen/box/smartCasts/kt42517.kt"); } + @Test @TestMetadata("kt44804.kt") public void testKt44804() throws Exception { runTest("compiler/testData/codegen/box/smartCasts/kt44804.kt"); } + @Test @TestMetadata("kt44814.kt") public void testKt44814() throws Exception { runTest("compiler/testData/codegen/box/smartCasts/kt44814.kt"); } + @Test @TestMetadata("kt44932.kt") public void testKt44932() throws Exception { runTest("compiler/testData/codegen/box/smartCasts/kt44932.kt"); } + @Test @TestMetadata("kt44942.kt") public void testKt44942() throws Exception { runTest("compiler/testData/codegen/box/smartCasts/kt44942.kt"); } + @Test @TestMetadata("kt52432.kt") public void testKt52432() throws Exception { runTest("compiler/testData/codegen/box/smartCasts/kt52432.kt"); } + @Test @TestMetadata("lambdaArgumentWithoutType.kt") public void testLambdaArgumentWithoutType() throws Exception { runTest("compiler/testData/codegen/box/smartCasts/lambdaArgumentWithoutType.kt"); } + @Test @TestMetadata("multipleSmartCast.kt") public void testMultipleSmartCast() throws Exception { runTest("compiler/testData/codegen/box/smartCasts/multipleSmartCast.kt"); } + @Test @TestMetadata("nullSmartCast.kt") public void testNullSmartCast() throws Exception { runTest("compiler/testData/codegen/box/smartCasts/nullSmartCast.kt"); } + @Test @TestMetadata("propertyInitializationAfterSmartCast.kt") public void testPropertyInitializationAfterSmartCast() throws Exception { runTest("compiler/testData/codegen/box/smartCasts/propertyInitializationAfterSmartCast.kt"); } + @Test @TestMetadata("smartCastInsideIf.kt") public void testSmartCastInsideIf() throws Exception { runTest("compiler/testData/codegen/box/smartCasts/smartCastInsideIf.kt"); } + @Test @TestMetadata("whenSmartCast.kt") public void testWhenSmartCast() throws Exception { runTest("compiler/testData/codegen/box/smartCasts/whenSmartCast.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/specialBuiltins") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SpecialBuiltins extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class SpecialBuiltins { + @Test public void testAllFilesPresentInSpecialBuiltins() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/specialBuiltins"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("bridgeNotEmptyMap.kt") public void testBridgeNotEmptyMap() throws Exception { runTest("compiler/testData/codegen/box/specialBuiltins/bridgeNotEmptyMap.kt"); } + @Test @TestMetadata("bridges.kt") public void testBridges() throws Exception { runTest("compiler/testData/codegen/box/specialBuiltins/bridges.kt"); } + @Test @TestMetadata("commonBridgesTarget.kt") public void testCommonBridgesTarget() throws Exception { runTest("compiler/testData/codegen/box/specialBuiltins/commonBridgesTarget.kt"); } + @Test @TestMetadata("emptyList.kt") public void testEmptyList() throws Exception { runTest("compiler/testData/codegen/box/specialBuiltins/emptyList.kt"); } + @Test @TestMetadata("emptyMap.kt") public void testEmptyMap() throws Exception { runTest("compiler/testData/codegen/box/specialBuiltins/emptyMap.kt"); } + @Test @TestMetadata("emptyStringMap.kt") public void testEmptyStringMap() throws Exception { runTest("compiler/testData/codegen/box/specialBuiltins/emptyStringMap.kt"); } + @Test @TestMetadata("entrySetSOE.kt") public void testEntrySetSOE() throws Exception { runTest("compiler/testData/codegen/box/specialBuiltins/entrySetSOE.kt"); } + @Test @TestMetadata("enumAsOrdinaled.kt") public void testEnumAsOrdinaled() throws Exception { runTest("compiler/testData/codegen/box/specialBuiltins/enumAsOrdinaled.kt"); } + @Test @TestMetadata("exceptionCause.kt") public void testExceptionCause() throws Exception { runTest("compiler/testData/codegen/box/specialBuiltins/exceptionCause.kt"); } + @Test @TestMetadata("explicitSuperCall.kt") public void testExplicitSuperCall() throws Exception { runTest("compiler/testData/codegen/box/specialBuiltins/explicitSuperCall.kt"); } + @Test @TestMetadata("irrelevantRemoveAtOverride.kt") public void testIrrelevantRemoveAtOverride() throws Exception { runTest("compiler/testData/codegen/box/specialBuiltins/irrelevantRemoveAtOverride.kt"); } + @Test @TestMetadata("maps.kt") public void testMaps() throws Exception { runTest("compiler/testData/codegen/box/specialBuiltins/maps.kt"); } + @Test @TestMetadata("noSpecialBridgeInSuperClass.kt") public void testNoSpecialBridgeInSuperClass() throws Exception { runTest("compiler/testData/codegen/box/specialBuiltins/noSpecialBridgeInSuperClass.kt"); } + @Test @TestMetadata("notEmptyListAny.kt") public void testNotEmptyListAny() throws Exception { runTest("compiler/testData/codegen/box/specialBuiltins/notEmptyListAny.kt"); } + @Test @TestMetadata("notEmptyMap.kt") public void testNotEmptyMap() throws Exception { runTest("compiler/testData/codegen/box/specialBuiltins/notEmptyMap.kt"); } + @Test @TestMetadata("redundantStubForSize.kt") public void testRedundantStubForSize() throws Exception { runTest("compiler/testData/codegen/box/specialBuiltins/redundantStubForSize.kt"); } + @Test @TestMetadata("removeAtTwoSpecialBridges.kt") public void testRemoveAtTwoSpecialBridges() throws Exception { runTest("compiler/testData/codegen/box/specialBuiltins/removeAtTwoSpecialBridges.kt"); } + @Test @TestMetadata("removeSetInt.kt") public void testRemoveSetInt() throws Exception { runTest("compiler/testData/codegen/box/specialBuiltins/removeSetInt.kt"); } + @Test @TestMetadata("throwable.kt") public void testThrowable() throws Exception { runTest("compiler/testData/codegen/box/specialBuiltins/throwable.kt"); } + @Test @TestMetadata("throwableCause.kt") public void testThrowableCause() throws Exception { runTest("compiler/testData/codegen/box/specialBuiltins/throwableCause.kt"); } + @Test @TestMetadata("throwableComplex.kt") public void testThrowableComplex() throws Exception { runTest("compiler/testData/codegen/box/specialBuiltins/throwableComplex.kt"); } + @Test @TestMetadata("throwableImpl.kt") public void testThrowableImpl() throws Exception { runTest("compiler/testData/codegen/box/specialBuiltins/throwableImpl.kt"); } + @Test @TestMetadata("throwableImplWithSecondaryConstructor.kt") public void testThrowableImplWithSecondaryConstructor() throws Exception { runTest("compiler/testData/codegen/box/specialBuiltins/throwableImplWithSecondaryConstructor.kt"); } + @Test @TestMetadata("valuesInsideEnum.kt") public void testValuesInsideEnum() throws Exception { runTest("compiler/testData/codegen/box/specialBuiltins/valuesInsideEnum.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/statics") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Statics extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Statics { + @Test public void testAllFilesPresentInStatics() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/statics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("anonymousInitializerIObject.kt") public void testAnonymousInitializerIObject() throws Exception { runTest("compiler/testData/codegen/box/statics/anonymousInitializerIObject.kt"); } + @Test @TestMetadata("anonymousInitializerInClassObject.kt") public void testAnonymousInitializerInClassObject() throws Exception { runTest("compiler/testData/codegen/box/statics/anonymousInitializerInClassObject.kt"); } + @Test @TestMetadata("incInClassObject.kt") public void testIncInClassObject() throws Exception { runTest("compiler/testData/codegen/box/statics/incInClassObject.kt"); } + @Test @TestMetadata("incInObject.kt") public void testIncInObject() throws Exception { runTest("compiler/testData/codegen/box/statics/incInObject.kt"); } + @Test @TestMetadata("inheritedPropertyInClassObject.kt") public void testInheritedPropertyInClassObject() throws Exception { runTest("compiler/testData/codegen/box/statics/inheritedPropertyInClassObject.kt"); } + @Test @TestMetadata("inheritedPropertyInObject.kt") public void testInheritedPropertyInObject() throws Exception { runTest("compiler/testData/codegen/box/statics/inheritedPropertyInObject.kt"); } + @Test @TestMetadata("kt8089.kt") public void testKt8089() throws Exception { runTest("compiler/testData/codegen/box/statics/kt8089.kt"); } + @Test @TestMetadata("syntheticAccessor.kt") public void testSyntheticAccessor() throws Exception { runTest("compiler/testData/codegen/box/statics/syntheticAccessor.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/storeStackBeforeInline") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class StoreStackBeforeInline extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class StoreStackBeforeInline { + @Test public void testAllFilesPresentInStoreStackBeforeInline() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/storeStackBeforeInline"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("differentTypes.kt") public void testDifferentTypes() throws Exception { runTest("compiler/testData/codegen/box/storeStackBeforeInline/differentTypes.kt"); } + @Test @TestMetadata("primitiveMerge.kt") public void testPrimitiveMerge() throws Exception { runTest("compiler/testData/codegen/box/storeStackBeforeInline/primitiveMerge.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/storeStackBeforeInline/simple.kt"); } + @Test @TestMetadata("unreachableMarker.kt") public void testUnreachableMarker() throws Exception { runTest("compiler/testData/codegen/box/storeStackBeforeInline/unreachableMarker.kt"); } + @Test @TestMetadata("withLambda.kt") public void testWithLambda() throws Exception { runTest("compiler/testData/codegen/box/storeStackBeforeInline/withLambda.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/strings") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Strings extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Strings { + @Test public void testAllFilesPresentInStrings() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/strings"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("concatDynamicWithConstants.kt") public void testConcatDynamicWithConstants() throws Exception { runTest("compiler/testData/codegen/box/strings/concatDynamicWithConstants.kt"); } + @Test @TestMetadata("concatDynamicWithSpecialSymbols.kt") public void testConcatDynamicWithSpecialSymbols() throws Exception { runTest("compiler/testData/codegen/box/strings/concatDynamicWithSpecialSymbols.kt"); } + @Test @TestMetadata("concatGenericWithNullablePrimitiveUpperBound.kt") public void testConcatGenericWithNullablePrimitiveUpperBound() throws Exception { runTest("compiler/testData/codegen/box/strings/concatGenericWithNullablePrimitiveUpperBound.kt"); } + @Test @TestMetadata("concatGenericWithPrimitiveUpperBound.kt") public void testConcatGenericWithPrimitiveUpperBound() throws Exception { runTest("compiler/testData/codegen/box/strings/concatGenericWithPrimitiveUpperBound.kt"); } + @Test @TestMetadata("concatGenericWithStringUpperBound.kt") public void testConcatGenericWithStringUpperBound() throws Exception { runTest("compiler/testData/codegen/box/strings/concatGenericWithStringUpperBound.kt"); } + @Test @TestMetadata("concatNullableGenericWithPrimitiveUpperBound.kt") public void testConcatNullableGenericWithPrimitiveUpperBound() throws Exception { runTest("compiler/testData/codegen/box/strings/concatNullableGenericWithPrimitiveUpperBound.kt"); } + @Test @TestMetadata("constInStringTemplate.kt") public void testConstInStringTemplate() throws Exception { runTest("compiler/testData/codegen/box/strings/constInStringTemplate.kt"); } + @Test @TestMetadata("ea35743.kt") public void testEa35743() throws Exception { runTest("compiler/testData/codegen/box/strings/ea35743.kt"); } + @Test @TestMetadata("forInString.kt") public void testForInString() throws Exception { runTest("compiler/testData/codegen/box/strings/forInString.kt"); } + @Test @TestMetadata("interpolation.kt") public void testInterpolation() throws Exception { runTest("compiler/testData/codegen/box/strings/interpolation.kt"); } + @Test @TestMetadata("kt13213.kt") public void testKt13213() throws Exception { runTest("compiler/testData/codegen/box/strings/kt13213.kt"); } + @Test @TestMetadata("kt13213a.kt") public void testKt13213a() throws Exception { runTest("compiler/testData/codegen/box/strings/kt13213a.kt"); } + @Test @TestMetadata("kt2592.kt") public void testKt2592() throws Exception { runTest("compiler/testData/codegen/box/strings/kt2592.kt"); } + @Test @TestMetadata("kt3571.kt") public void testKt3571() throws Exception { runTest("compiler/testData/codegen/box/strings/kt3571.kt"); } + @Test @TestMetadata("kt3652.kt") public void testKt3652() throws Exception { runTest("compiler/testData/codegen/box/strings/kt3652.kt"); } + @Test @TestMetadata("kt47917.kt") public void testKt47917() throws Exception { runTest("compiler/testData/codegen/box/strings/kt47917.kt"); } + @Test @TestMetadata("kt50140.kt") public void testKt50140() throws Exception { runTest("compiler/testData/codegen/box/strings/kt50140.kt"); } + @Test @TestMetadata("kt5389_stringBuilderGet.kt") public void testKt5389_stringBuilderGet() throws Exception { runTest("compiler/testData/codegen/box/strings/kt5389_stringBuilderGet.kt"); } + @Test @TestMetadata("kt5956.kt") public void testKt5956() throws Exception { runTest("compiler/testData/codegen/box/strings/kt5956.kt"); } + @Test @TestMetadata("kt881.kt") public void testKt881() throws Exception { runTest("compiler/testData/codegen/box/strings/kt881.kt"); } + @Test @TestMetadata("kt889.kt") public void testKt889() throws Exception { runTest("compiler/testData/codegen/box/strings/kt889.kt"); } + @Test @TestMetadata("kt894.kt") public void testKt894() throws Exception { runTest("compiler/testData/codegen/box/strings/kt894.kt"); } + @Test @TestMetadata("multilineStringsWithTemplates.kt") public void testMultilineStringsWithTemplates() throws Exception { runTest("compiler/testData/codegen/box/strings/multilineStringsWithTemplates.kt"); } + @Test @TestMetadata("nestedConcat.kt") public void testNestedConcat() throws Exception { runTest("compiler/testData/codegen/box/strings/nestedConcat.kt"); } + @Test @TestMetadata("rawStrings.kt") public void testRawStrings() throws Exception { runTest("compiler/testData/codegen/box/strings/rawStrings.kt"); } + @Test @TestMetadata("rawStringsWithManyQuotes.kt") public void testRawStringsWithManyQuotes() throws Exception { runTest("compiler/testData/codegen/box/strings/rawStringsWithManyQuotes.kt"); } + @Test @TestMetadata("simpleStringPlus.kt") public void testSimpleStringPlus() throws Exception { runTest("compiler/testData/codegen/box/strings/simpleStringPlus.kt"); } + @Test @TestMetadata("singleConcatNullable.kt") public void testSingleConcatNullable() throws Exception { runTest("compiler/testData/codegen/box/strings/singleConcatNullable.kt"); } + @Test @TestMetadata("stringBuilderAppend.kt") public void testStringBuilderAppend() throws Exception { runTest("compiler/testData/codegen/box/strings/stringBuilderAppend.kt"); } + @Test @TestMetadata("stringPlusOnlyWorksOnString.kt") public void testStringPlusOnlyWorksOnString() throws Exception { runTest("compiler/testData/codegen/box/strings/stringPlusOnlyWorksOnString.kt"); } + @Test @TestMetadata("stringPlusOverride.kt") public void testStringPlusOverride() throws Exception { runTest("compiler/testData/codegen/box/strings/stringPlusOverride.kt"); } + @Test @TestMetadata("surrogatePair.kt") public void testSurrogatePair() throws Exception { runTest("compiler/testData/codegen/box/strings/surrogatePair.kt"); } + @Test @TestMetadata("trimOptimization.kt") public void testTrimOptimization() throws Exception { runTest("compiler/testData/codegen/box/strings/trimOptimization.kt"); } + @Test @TestMetadata("twoArgumentNullableStringOperatorPlus.kt") public void testTwoArgumentNullableStringOperatorPlus() throws Exception { runTest("compiler/testData/codegen/box/strings/twoArgumentNullableStringOperatorPlus.kt"); } + @Test @TestMetadata("twoArgumentNullableStringPlus.kt") public void testTwoArgumentNullableStringPlus() throws Exception { runTest("compiler/testData/codegen/box/strings/twoArgumentNullableStringPlus.kt"); } + @Test @TestMetadata("twoArgumentStringTemplate.kt") public void testTwoArgumentStringTemplate() throws Exception { runTest("compiler/testData/codegen/box/strings/twoArgumentStringTemplate.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/super") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Super extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Super { + @Test public void testAllFilesPresentInSuper() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("basicmethodSuperClass.kt") public void testBasicmethodSuperClass() throws Exception { runTest("compiler/testData/codegen/box/super/basicmethodSuperClass.kt"); } + @Test @TestMetadata("basicmethodSuperTrait.kt") public void testBasicmethodSuperTrait() throws Exception { runTest("compiler/testData/codegen/box/super/basicmethodSuperTrait.kt"); } + @Test @TestMetadata("basicproperty.kt") public void testBasicproperty() throws Exception { runTest("compiler/testData/codegen/box/super/basicproperty.kt"); } + @Test @TestMetadata("enclosedFun.kt") public void testEnclosedFun() throws Exception { runTest("compiler/testData/codegen/box/super/enclosedFun.kt"); } + @Test @TestMetadata("enclosedVar.kt") public void testEnclosedVar() throws Exception { runTest("compiler/testData/codegen/box/super/enclosedVar.kt"); } + @Test @TestMetadata("innerClassLabeledSuper.kt") public void testInnerClassLabeledSuper() throws Exception { runTest("compiler/testData/codegen/box/super/innerClassLabeledSuper.kt"); } + @Test @TestMetadata("innerClassLabeledSuper2.kt") public void testInnerClassLabeledSuper2() throws Exception { runTest("compiler/testData/codegen/box/super/innerClassLabeledSuper2.kt"); } + @Test @TestMetadata("innerClassLabeledSuperProperty.kt") public void testInnerClassLabeledSuperProperty() throws Exception { runTest("compiler/testData/codegen/box/super/innerClassLabeledSuperProperty.kt"); } + @Test @TestMetadata("innerClassLabeledSuperProperty2.kt") public void testInnerClassLabeledSuperProperty2() throws Exception { runTest("compiler/testData/codegen/box/super/innerClassLabeledSuperProperty2.kt"); } + @Test @TestMetadata("innerClassQualifiedFunctionCall.kt") public void testInnerClassQualifiedFunctionCall() throws Exception { runTest("compiler/testData/codegen/box/super/innerClassQualifiedFunctionCall.kt"); } + @Test @TestMetadata("innerClassQualifiedPropertyAccess.kt") public void testInnerClassQualifiedPropertyAccess() throws Exception { runTest("compiler/testData/codegen/box/super/innerClassQualifiedPropertyAccess.kt"); } + @Test @TestMetadata("interfaceHashCode.kt") public void testInterfaceHashCode() throws Exception { runTest("compiler/testData/codegen/box/super/interfaceHashCode.kt"); } + @Test @TestMetadata("kt14243.kt") public void testKt14243() throws Exception { runTest("compiler/testData/codegen/box/super/kt14243.kt"); } + @Test @TestMetadata("kt14243_2.kt") public void testKt14243_2() throws Exception { runTest("compiler/testData/codegen/box/super/kt14243_2.kt"); } + @Test @TestMetadata("kt14243_class.kt") public void testKt14243_class() throws Exception { runTest("compiler/testData/codegen/box/super/kt14243_class.kt"); } + @Test @TestMetadata("kt14243_prop.kt") public void testKt14243_prop() throws Exception { runTest("compiler/testData/codegen/box/super/kt14243_prop.kt"); } + @Test @TestMetadata("kt3492ClassFun.kt") public void testKt3492ClassFun() throws Exception { runTest("compiler/testData/codegen/box/super/kt3492ClassFun.kt"); } + @Test @TestMetadata("kt3492ClassProperty.kt") public void testKt3492ClassProperty() throws Exception { runTest("compiler/testData/codegen/box/super/kt3492ClassProperty.kt"); } + @Test @TestMetadata("kt3492TraitFun.kt") public void testKt3492TraitFun() throws Exception { runTest("compiler/testData/codegen/box/super/kt3492TraitFun.kt"); } + @Test @TestMetadata("kt3492TraitProperty.kt") public void testKt3492TraitProperty() throws Exception { runTest("compiler/testData/codegen/box/super/kt3492TraitProperty.kt"); } + @Test @TestMetadata("kt4173.kt") public void testKt4173() throws Exception { runTest("compiler/testData/codegen/box/super/kt4173.kt"); } + @Test @TestMetadata("kt4173_2.kt") public void testKt4173_2() throws Exception { runTest("compiler/testData/codegen/box/super/kt4173_2.kt"); } + @Test @TestMetadata("kt4173_3.kt") public void testKt4173_3() throws Exception { runTest("compiler/testData/codegen/box/super/kt4173_3.kt"); } + @Test @TestMetadata("kt4982.kt") public void testKt4982() throws Exception { runTest("compiler/testData/codegen/box/super/kt4982.kt"); } + @Test @TestMetadata("multipleSuperTraits.kt") public void testMultipleSuperTraits() throws Exception { runTest("compiler/testData/codegen/box/super/multipleSuperTraits.kt"); } + @Test @TestMetadata("superCallToNonGenericImplThroughGenericDefaultImpls.kt") public void testSuperCallToNonGenericImplThroughGenericDefaultImpls() throws Exception { runTest("compiler/testData/codegen/box/super/superCallToNonGenericImplThroughGenericDefaultImpls.kt"); } + @Test @TestMetadata("traitproperty.kt") public void testTraitproperty() throws Exception { runTest("compiler/testData/codegen/box/super/traitproperty.kt"); } + @Test @TestMetadata("unqualifiedSuper.kt") public void testUnqualifiedSuper() throws Exception { runTest("compiler/testData/codegen/box/super/unqualifiedSuper.kt"); } + @Test @TestMetadata("unqualifiedSuperWithDeeperHierarchies.kt") public void testUnqualifiedSuperWithDeeperHierarchies() throws Exception { runTest("compiler/testData/codegen/box/super/unqualifiedSuperWithDeeperHierarchies.kt"); } + @Test @TestMetadata("unqualifiedSuperWithMethodsOfAny.kt") public void testUnqualifiedSuperWithMethodsOfAny() throws Exception { runTest("compiler/testData/codegen/box/super/unqualifiedSuperWithMethodsOfAny.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/super/superConstructor") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SuperConstructor extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class SuperConstructor { + @Test public void testAllFilesPresentInSuperConstructor() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super/superConstructor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt13846.kt") public void testKt13846() throws Exception { runTest("compiler/testData/codegen/box/super/superConstructor/kt13846.kt"); } + @Test @TestMetadata("kt17464_arrayOf.kt") public void testKt17464_arrayOf() throws Exception { runTest("compiler/testData/codegen/box/super/superConstructor/kt17464_arrayOf.kt"); } + @Test @TestMetadata("kt17464_linkedMapOf.kt") public void testKt17464_linkedMapOf() throws Exception { runTest("compiler/testData/codegen/box/super/superConstructor/kt17464_linkedMapOf.kt"); } + @Test @TestMetadata("kt18356.kt") public void testKt18356() throws Exception { runTest("compiler/testData/codegen/box/super/superConstructor/kt18356.kt"); } + @Test @TestMetadata("kt18356_2.kt") public void testKt18356_2() throws Exception { runTest("compiler/testData/codegen/box/super/superConstructor/kt18356_2.kt"); } + @Test @TestMetadata("objectExtendsInner.kt") public void testObjectExtendsInner() throws Exception { runTest("compiler/testData/codegen/box/super/superConstructor/objectExtendsInner.kt"); } + @Test @TestMetadata("objectExtendsLocalInner.kt") public void testObjectExtendsLocalInner() throws Exception { runTest("compiler/testData/codegen/box/super/superConstructor/objectExtendsLocalInner.kt"); @@ -31352,257 +34924,275 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/suppressions") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Suppressions extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Suppressions { + @Test public void testAllFilesPresentInSuppressions() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/suppressions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("suppressInvisible.kt") public void testSuppressInvisible() throws Exception { runTest("compiler/testData/codegen/box/suppressions/suppressInvisible.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/suspendConversion") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SuspendConversion extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class SuspendConversion { + @Test public void testAllFilesPresentInSuspendConversion() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/suspendConversion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("basicSuspendConversion.kt") public void testBasicSuspendConversion() throws Exception { runTest("compiler/testData/codegen/box/suspendConversion/basicSuspendConversion.kt"); } + @Test @TestMetadata("basicSuspendConversionDefault.kt") public void testBasicSuspendConversionDefault() throws Exception { runTest("compiler/testData/codegen/box/suspendConversion/basicSuspendConversionDefault.kt"); } + @Test @TestMetadata("basicSuspendConversionForCallableReference.kt") public void testBasicSuspendConversionForCallableReference() throws Exception { runTest("compiler/testData/codegen/box/suspendConversion/basicSuspendConversionForCallableReference.kt"); } + @Test @TestMetadata("chainedFunSuspendConversionForSimpleExpression.kt") public void testChainedFunSuspendConversionForSimpleExpression() throws Exception { runTest("compiler/testData/codegen/box/suspendConversion/chainedFunSuspendConversionForSimpleExpression.kt"); } + @Test @TestMetadata("kt50949_suspendConversionForExtensionFunction.kt") public void testKt50949_suspendConversionForExtensionFunction() throws Exception { runTest("compiler/testData/codegen/box/suspendConversion/kt50949_suspendConversionForExtensionFunction.kt"); } + @Test @TestMetadata("overloadResolutionBySuspendModifier.kt") public void testOverloadResolutionBySuspendModifier() throws Exception { runTest("compiler/testData/codegen/box/suspendConversion/overloadResolutionBySuspendModifier.kt"); } + @Test @TestMetadata("severalConversionsInOneCall.kt") public void testSeveralConversionsInOneCall() throws Exception { runTest("compiler/testData/codegen/box/suspendConversion/severalConversionsInOneCall.kt"); } + @Test @TestMetadata("suspendAndFunConversionInDisabledMode.kt") public void testSuspendAndFunConversionInDisabledMode() throws Exception { runTest("compiler/testData/codegen/box/suspendConversion/suspendAndFunConversionInDisabledMode.kt"); } + @Test @TestMetadata("suspendConversionCompatibility.kt") public void testSuspendConversionCompatibility() throws Exception { runTest("compiler/testData/codegen/box/suspendConversion/suspendConversionCompatibility.kt"); } + @Test @TestMetadata("suspendConversionOnVarargElements.kt") public void testSuspendConversionOnVarargElements() throws Exception { runTest("compiler/testData/codegen/box/suspendConversion/suspendConversionOnVarargElements.kt"); } + @Test @TestMetadata("suspendConversionWithFunInterfaces.kt") public void testSuspendConversionWithFunInterfaces() throws Exception { runTest("compiler/testData/codegen/box/suspendConversion/suspendConversionWithFunInterfaces.kt"); } + @Test @TestMetadata("suspendConversionWithReferenceAdaptation.kt") public void testSuspendConversionWithReferenceAdaptation() throws Exception { runTest("compiler/testData/codegen/box/suspendConversion/suspendConversionWithReferenceAdaptation.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/synchronized") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Synchronized extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Synchronized { + @Test public void testAllFilesPresentInSynchronized() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/synchronized"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/syntheticAccessors") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SyntheticAccessors extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class SyntheticAccessors { + @Test @TestMetadata("accessorForAbstractProtected.kt") public void testAccessorForAbstractProtected() throws Exception { runTest("compiler/testData/codegen/box/syntheticAccessors/accessorForAbstractProtected.kt"); } + @Test @TestMetadata("accessorForGenericConstructor.kt") public void testAccessorForGenericConstructor() throws Exception { runTest("compiler/testData/codegen/box/syntheticAccessors/accessorForGenericConstructor.kt"); } + @Test @TestMetadata("accessorForGenericMethod.kt") public void testAccessorForGenericMethod() throws Exception { runTest("compiler/testData/codegen/box/syntheticAccessors/accessorForGenericMethod.kt"); } + @Test @TestMetadata("accessorForGenericMethodWithDefaults.kt") public void testAccessorForGenericMethodWithDefaults() throws Exception { runTest("compiler/testData/codegen/box/syntheticAccessors/accessorForGenericMethodWithDefaults.kt"); } + @Test @TestMetadata("accessorForProtected.kt") public void testAccessorForProtected() throws Exception { runTest("compiler/testData/codegen/box/syntheticAccessors/accessorForProtected.kt"); } + @Test @TestMetadata("accessorForProtectedInvokeVirtual.kt") public void testAccessorForProtectedInvokeVirtual() throws Exception { runTest("compiler/testData/codegen/box/syntheticAccessors/accessorForProtectedInvokeVirtual.kt"); } + @Test @TestMetadata("accessorForProtectedPropertyReference.kt") public void testAccessorForProtectedPropertyReference() throws Exception { runTest("compiler/testData/codegen/box/syntheticAccessors/accessorForProtectedPropertyReference.kt"); } + @Test public void testAllFilesPresentInSyntheticAccessors() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/syntheticAccessors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("inline.kt") public void testInline() throws Exception { runTest("compiler/testData/codegen/box/syntheticAccessors/inline.kt"); } + @Test @TestMetadata("inlineInOtherClass.kt") public void testInlineInOtherClass() throws Exception { runTest("compiler/testData/codegen/box/syntheticAccessors/inlineInOtherClass.kt"); } + @Test @TestMetadata("kt10047.kt") public void testKt10047() throws Exception { runTest("compiler/testData/codegen/box/syntheticAccessors/kt10047.kt"); } + @Test @TestMetadata("kt21258_indirect.kt") public void testKt21258_indirect() throws Exception { runTest("compiler/testData/codegen/box/syntheticAccessors/kt21258_indirect.kt"); } + @Test @TestMetadata("kt21258_simple.kt") public void testKt21258_simple() throws Exception { runTest("compiler/testData/codegen/box/syntheticAccessors/kt21258_simple.kt"); } + @Test @TestMetadata("kt49316.kt") public void testKt49316() throws Exception { runTest("compiler/testData/codegen/box/syntheticAccessors/kt49316.kt"); } + @Test @TestMetadata("kt9717.kt") public void testKt9717() throws Exception { runTest("compiler/testData/codegen/box/syntheticAccessors/kt9717.kt"); } + @Test @TestMetadata("kt9717DifferentPackages.kt") public void testKt9717DifferentPackages() throws Exception { runTest("compiler/testData/codegen/box/syntheticAccessors/kt9717DifferentPackages.kt"); } + @Test @TestMetadata("kt9958.kt") public void testKt9958() throws Exception { runTest("compiler/testData/codegen/box/syntheticAccessors/kt9958.kt"); } + @Test @TestMetadata("kt9958Interface.kt") public void testKt9958Interface() throws Exception { runTest("compiler/testData/codegen/box/syntheticAccessors/kt9958Interface.kt"); } + @Test @TestMetadata("protectedFromLambda.kt") public void testProtectedFromLambda() throws Exception { runTest("compiler/testData/codegen/box/syntheticAccessors/protectedFromLambda.kt"); } + @Test @TestMetadata("superCallFromMultipleSubclasses.kt") public void testSuperCallFromMultipleSubclasses() throws Exception { runTest("compiler/testData/codegen/box/syntheticAccessors/superCallFromMultipleSubclasses.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/syntheticAccessors/protectedJavaFieldAccessor") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ProtectedJavaFieldAccessor extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ProtectedJavaFieldAccessor { + @Test public void testAllFilesPresentInProtectedJavaFieldAccessor() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/syntheticAccessors/protectedJavaFieldAccessor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/syntheticAccessors/protectedMemberReferenceAccessor") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ProtectedMemberReferenceAccessor extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ProtectedMemberReferenceAccessor { + @Test public void testAllFilesPresentInProtectedMemberReferenceAccessor() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/syntheticAccessors/protectedMemberReferenceAccessor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt46597_crossinline_method.kt") public void testKt46597_crossinline_method() throws Exception { runTest("compiler/testData/codegen/box/syntheticAccessors/protectedMemberReferenceAccessor/kt46597_crossinline_method.kt"); } + @Test @TestMetadata("kt46597_crossinline_property.kt") public void testKt46597_crossinline_property() throws Exception { runTest("compiler/testData/codegen/box/syntheticAccessors/protectedMemberReferenceAccessor/kt46597_crossinline_property.kt"); } + @Test @TestMetadata("kt46597_method.kt") public void testKt46597_method() throws Exception { runTest("compiler/testData/codegen/box/syntheticAccessors/protectedMemberReferenceAccessor/kt46597_method.kt"); } + @Test @TestMetadata("kt46597_property.kt") public void testKt46597_property() throws Exception { runTest("compiler/testData/codegen/box/syntheticAccessors/protectedMemberReferenceAccessor/kt46597_property.kt"); @@ -31610,1618 +35200,1813 @@ public class IrCodegenBoxWasmTestGenerated extends AbstractIrCodegenBoxWasmTest } } + @Nested @TestMetadata("compiler/testData/codegen/box/syntheticExtensions") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class SyntheticExtensions extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class SyntheticExtensions { + @Test public void testAllFilesPresentInSyntheticExtensions() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/syntheticExtensions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/throws") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Throws extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Throws { + @Test public void testAllFilesPresentInThrows() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/throws"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("compiler/testData/codegen/box/toArray") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ToArray extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ToArray { + @Test public void testAllFilesPresentInToArray() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/toArray"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt3177-toTypedArray.kt") public void testKt3177_toTypedArray() throws Exception { runTest("compiler/testData/codegen/box/toArray/kt3177-toTypedArray.kt"); } + @Test @TestMetadata("returnToTypedArray.kt") public void testReturnToTypedArray() throws Exception { runTest("compiler/testData/codegen/box/toArray/returnToTypedArray.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/topLevelInitializtion") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TopLevelInitializtion extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class TopLevelInitializtion { + @Test public void testAllFilesPresentInTopLevelInitializtion() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/topLevelInitializtion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("failInInitializer1.kt") public void testFailInInitializer1() throws Exception { runTest("compiler/testData/codegen/box/topLevelInitializtion/failInInitializer1.kt"); } + @Test @TestMetadata("failInInitializer2.kt") public void testFailInInitializer2() throws Exception { runTest("compiler/testData/codegen/box/topLevelInitializtion/failInInitializer2.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/topLevelPrivate") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TopLevelPrivate extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class TopLevelPrivate { + @Test public void testAllFilesPresentInTopLevelPrivate() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/topLevelPrivate"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("privateInInlineNested.kt") public void testPrivateInInlineNested() throws Exception { runTest("compiler/testData/codegen/box/topLevelPrivate/privateInInlineNested.kt"); } + @Test @TestMetadata("syntheticAccessor.kt") public void testSyntheticAccessor() throws Exception { runTest("compiler/testData/codegen/box/topLevelPrivate/syntheticAccessor.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/trailingComma") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TrailingComma extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class TrailingComma { + @Test public void testAllFilesPresentInTrailingComma() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/trailingComma"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("noDisambiguation.kt") public void testNoDisambiguation() throws Exception { runTest("compiler/testData/codegen/box/trailingComma/noDisambiguation.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/traits") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Traits extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Traits { + @Test @TestMetadata("abstractClassWithFakeOverride.kt") public void testAbstractClassWithFakeOverride() throws Exception { runTest("compiler/testData/codegen/box/traits/abstractClassWithFakeOverride.kt"); } + @Test public void testAllFilesPresentInTraits() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/traits"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("diamondPropertyAccessors.kt") public void testDiamondPropertyAccessors() throws Exception { runTest("compiler/testData/codegen/box/traits/diamondPropertyAccessors.kt"); } + @Test @TestMetadata("doubleDiamond.kt") public void testDoubleDiamond() throws Exception { runTest("compiler/testData/codegen/box/traits/doubleDiamond.kt"); } + @Test @TestMetadata("doubleGenericDiamond.kt") public void testDoubleGenericDiamond() throws Exception { runTest("compiler/testData/codegen/box/traits/doubleGenericDiamond.kt"); } + @Test @TestMetadata("genericMethod.kt") public void testGenericMethod() throws Exception { runTest("compiler/testData/codegen/box/traits/genericMethod.kt"); } + @Test @TestMetadata("indirectlyInheritPropertyGetter.kt") public void testIndirectlyInheritPropertyGetter() throws Exception { runTest("compiler/testData/codegen/box/traits/indirectlyInheritPropertyGetter.kt"); } + @Test @TestMetadata("inheritedFun.kt") public void testInheritedFun() throws Exception { runTest("compiler/testData/codegen/box/traits/inheritedFun.kt"); } + @Test @TestMetadata("inheritedVar.kt") public void testInheritedVar() throws Exception { runTest("compiler/testData/codegen/box/traits/inheritedVar.kt"); } + @Test @TestMetadata("interfaceWithNonAbstractFunIndirect.kt") public void testInterfaceWithNonAbstractFunIndirect() throws Exception { runTest("compiler/testData/codegen/box/traits/interfaceWithNonAbstractFunIndirect.kt"); } + @Test @TestMetadata("interfaceWithNonAbstractFunIndirectGeneric.kt") public void testInterfaceWithNonAbstractFunIndirectGeneric() throws Exception { runTest("compiler/testData/codegen/box/traits/interfaceWithNonAbstractFunIndirectGeneric.kt"); } + @Test @TestMetadata("kt1936.kt") public void testKt1936() throws Exception { runTest("compiler/testData/codegen/box/traits/kt1936.kt"); } + @Test @TestMetadata("kt1936_1.kt") public void testKt1936_1() throws Exception { runTest("compiler/testData/codegen/box/traits/kt1936_1.kt"); } + @Test @TestMetadata("kt2260.kt") public void testKt2260() throws Exception { runTest("compiler/testData/codegen/box/traits/kt2260.kt"); } + @Test @TestMetadata("kt2399.kt") public void testKt2399() throws Exception { runTest("compiler/testData/codegen/box/traits/kt2399.kt"); } + @Test @TestMetadata("kt2541.kt") public void testKt2541() throws Exception { runTest("compiler/testData/codegen/box/traits/kt2541.kt"); } + @Test @TestMetadata("kt3315.kt") public void testKt3315() throws Exception { runTest("compiler/testData/codegen/box/traits/kt3315.kt"); } + @Test @TestMetadata("kt3500.kt") public void testKt3500() throws Exception { runTest("compiler/testData/codegen/box/traits/kt3500.kt"); } + @Test @TestMetadata("kt3579.kt") public void testKt3579() throws Exception { runTest("compiler/testData/codegen/box/traits/kt3579.kt"); } + @Test @TestMetadata("kt3579_2.kt") public void testKt3579_2() throws Exception { runTest("compiler/testData/codegen/box/traits/kt3579_2.kt"); } + @Test @TestMetadata("kt36973.kt") public void testKt36973() throws Exception { runTest("compiler/testData/codegen/box/traits/kt36973.kt"); } + @Test @TestMetadata("kt5393.kt") public void testKt5393() throws Exception { runTest("compiler/testData/codegen/box/traits/kt5393.kt"); } + @Test @TestMetadata("kt5393_property.kt") public void testKt5393_property() throws Exception { runTest("compiler/testData/codegen/box/traits/kt5393_property.kt"); } + @Test @TestMetadata("multiple.kt") public void testMultiple() throws Exception { runTest("compiler/testData/codegen/box/traits/multiple.kt"); } + @Test @TestMetadata("privateInterfaceMethod.kt") public void testPrivateInterfaceMethod() throws Exception { runTest("compiler/testData/codegen/box/traits/privateInterfaceMethod.kt"); } + @Test @TestMetadata("receiverOfIntersectionType.kt") public void testReceiverOfIntersectionType() throws Exception { runTest("compiler/testData/codegen/box/traits/receiverOfIntersectionType.kt"); } + @Test @TestMetadata("sameNameMethodFromInterface.kt") public void testSameNameMethodFromInterface() throws Exception { runTest("compiler/testData/codegen/box/traits/sameNameMethodFromInterface.kt"); } + @Test @TestMetadata("syntheticAccessor.kt") public void testSyntheticAccessor() throws Exception { runTest("compiler/testData/codegen/box/traits/syntheticAccessor.kt"); } + @Test @TestMetadata("traitImplDelegationWithCovariantOverride.kt") public void testTraitImplDelegationWithCovariantOverride() throws Exception { runTest("compiler/testData/codegen/box/traits/traitImplDelegationWithCovariantOverride.kt"); } + @Test @TestMetadata("traitImplDiamond.kt") public void testTraitImplDiamond() throws Exception { runTest("compiler/testData/codegen/box/traits/traitImplDiamond.kt"); } + @Test @TestMetadata("traitImplGenericDelegation.kt") public void testTraitImplGenericDelegation() throws Exception { runTest("compiler/testData/codegen/box/traits/traitImplGenericDelegation.kt"); } + @Test @TestMetadata("traitWithPrivateExtension.kt") public void testTraitWithPrivateExtension() throws Exception { runTest("compiler/testData/codegen/box/traits/traitWithPrivateExtension.kt"); } + @Test @TestMetadata("traitWithPrivateMember.kt") public void testTraitWithPrivateMember() throws Exception { runTest("compiler/testData/codegen/box/traits/traitWithPrivateMember.kt"); } + @Test @TestMetadata("traitWithPrivateMemberAccessFromLambda.kt") public void testTraitWithPrivateMemberAccessFromLambda() throws Exception { runTest("compiler/testData/codegen/box/traits/traitWithPrivateMemberAccessFromLambda.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/typeInfo") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TypeInfo extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class TypeInfo { + @Test public void testAllFilesPresentInTypeInfo() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeInfo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("ifOrWhenSpecialCall.kt") public void testIfOrWhenSpecialCall() throws Exception { runTest("compiler/testData/codegen/box/typeInfo/ifOrWhenSpecialCall.kt"); } + @Test @TestMetadata("implicitSmartCastThis.kt") public void testImplicitSmartCastThis() throws Exception { runTest("compiler/testData/codegen/box/typeInfo/implicitSmartCastThis.kt"); } + @Test @TestMetadata("inheritance.kt") public void testInheritance() throws Exception { runTest("compiler/testData/codegen/box/typeInfo/inheritance.kt"); } + @Test @TestMetadata("kt2811.kt") public void testKt2811() throws Exception { runTest("compiler/testData/codegen/box/typeInfo/kt2811.kt"); } + @Test @TestMetadata("primitiveTypeInfo.kt") public void testPrimitiveTypeInfo() throws Exception { runTest("compiler/testData/codegen/box/typeInfo/primitiveTypeInfo.kt"); } + @Test @TestMetadata("smartCastThis.kt") public void testSmartCastThis() throws Exception { runTest("compiler/testData/codegen/box/typeInfo/smartCastThis.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/typeMapping") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class TypeMapping extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class TypeMapping { + @Test public void testAllFilesPresentInTypeMapping() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeMapping"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("kt2831.kt") public void testKt2831() throws Exception { runTest("compiler/testData/codegen/box/typeMapping/kt2831.kt"); } + @Test @TestMetadata("kt3286.kt") public void testKt3286() throws Exception { runTest("compiler/testData/codegen/box/typeMapping/kt3286.kt"); } + @Test @TestMetadata("kt3863.kt") public void testKt3863() throws Exception { runTest("compiler/testData/codegen/box/typeMapping/kt3863.kt"); } + @Test @TestMetadata("kt3976.kt") public void testKt3976() throws Exception { runTest("compiler/testData/codegen/box/typeMapping/kt3976.kt"); } + @Test @TestMetadata("nothing.kt") public void testNothing() throws Exception { runTest("compiler/testData/codegen/box/typeMapping/nothing.kt"); } + @Test @TestMetadata("nullNothing.kt") public void testNullNothing() throws Exception { runTest("compiler/testData/codegen/box/typeMapping/nullNothing.kt"); } + @Test @TestMetadata("nullableNothing.kt") public void testNullableNothing() throws Exception { runTest("compiler/testData/codegen/box/typeMapping/nullableNothing.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/typealias") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Typealias extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Typealias { + @Test public void testAllFilesPresentInTypealias() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typealias"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("enumEntryQualifier.kt") public void testEnumEntryQualifier() throws Exception { runTest("compiler/testData/codegen/box/typealias/enumEntryQualifier.kt"); } + @Test @TestMetadata("extensionFunction.kt") public void testExtensionFunction() throws Exception { runTest("compiler/testData/codegen/box/typealias/extensionFunction.kt"); } + @Test @TestMetadata("genericTypeAliasConstructor.kt") public void testGenericTypeAliasConstructor() throws Exception { runTest("compiler/testData/codegen/box/typealias/genericTypeAliasConstructor.kt"); } + @Test @TestMetadata("genericTypeAliasConstructor2.kt") public void testGenericTypeAliasConstructor2() throws Exception { runTest("compiler/testData/codegen/box/typealias/genericTypeAliasConstructor2.kt"); } + @Test @TestMetadata("incorrectTypeOfTypealiasForSuspendFTMM.kt") public void testIncorrectTypeOfTypealiasForSuspendFTMM() throws Exception { runTest("compiler/testData/codegen/box/typealias/incorrectTypeOfTypealiasForSuspendFTMM.kt"); } + @Test @TestMetadata("incorrectTypeOfTypealiasForSuspendFunctionalType.kt") public void testIncorrectTypeOfTypealiasForSuspendFunctionalType() throws Exception { runTest("compiler/testData/codegen/box/typealias/incorrectTypeOfTypealiasForSuspendFunctionalType.kt"); } + @Test @TestMetadata("innerClassTypeAliasConstructor.kt") public void testInnerClassTypeAliasConstructor() throws Exception { runTest("compiler/testData/codegen/box/typealias/innerClassTypeAliasConstructor.kt"); } + @Test @TestMetadata("innerClassTypeAliasConstructorInSupertypes.kt") public void testInnerClassTypeAliasConstructorInSupertypes() throws Exception { runTest("compiler/testData/codegen/box/typealias/innerClassTypeAliasConstructorInSupertypes.kt"); } + @Test @TestMetadata("kt15109.kt") public void testKt15109() throws Exception { runTest("compiler/testData/codegen/box/typealias/kt15109.kt"); } + @Test @TestMetadata("kt45308.kt") public void testKt45308() throws Exception { runTest("compiler/testData/codegen/box/typealias/kt45308.kt"); } + @Test @TestMetadata("objectLiteralConstructor.kt") public void testObjectLiteralConstructor() throws Exception { runTest("compiler/testData/codegen/box/typealias/objectLiteralConstructor.kt"); } + @Test @TestMetadata("privateInKlib.kt") public void testPrivateInKlib() throws Exception { runTest("compiler/testData/codegen/box/typealias/privateInKlib.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/typealias/simple.kt"); } + @Test @TestMetadata("typeAliasAsBareType.kt") public void testTypeAliasAsBareType() throws Exception { runTest("compiler/testData/codegen/box/typealias/typeAliasAsBareType.kt"); } + @Test @TestMetadata("typeAliasCompanion.kt") public void testTypeAliasCompanion() throws Exception { runTest("compiler/testData/codegen/box/typealias/typeAliasCompanion.kt"); } + @Test @TestMetadata("typeAliasConstructor.kt") public void testTypeAliasConstructor() throws Exception { runTest("compiler/testData/codegen/box/typealias/typeAliasConstructor.kt"); } + @Test @TestMetadata("typeAliasConstructorAccessor.kt") public void testTypeAliasConstructorAccessor() throws Exception { runTest("compiler/testData/codegen/box/typealias/typeAliasConstructorAccessor.kt"); } + @Test @TestMetadata("typeAliasConstructorForArray.kt") public void testTypeAliasConstructorForArray() throws Exception { runTest("compiler/testData/codegen/box/typealias/typeAliasConstructorForArray.kt"); } + @Test @TestMetadata("typeAliasConstructorInSuperCall.kt") public void testTypeAliasConstructorInSuperCall() throws Exception { runTest("compiler/testData/codegen/box/typealias/typeAliasConstructorInSuperCall.kt"); } + @Test @TestMetadata("typeAliasFunction.kt") public void testTypeAliasFunction() throws Exception { runTest("compiler/testData/codegen/box/typealias/typeAliasFunction.kt"); } + @Test @TestMetadata("typeAliasInAnonymousObjectType.kt") public void testTypeAliasInAnonymousObjectType() throws Exception { runTest("compiler/testData/codegen/box/typealias/typeAliasInAnonymousObjectType.kt"); } + @Test @TestMetadata("typeAliasObject.kt") public void testTypeAliasObject() throws Exception { runTest("compiler/testData/codegen/box/typealias/typeAliasObject.kt"); } + @Test @TestMetadata("typeAliasObjectCallable.kt") public void testTypeAliasObjectCallable() throws Exception { runTest("compiler/testData/codegen/box/typealias/typeAliasObjectCallable.kt"); } + @Test @TestMetadata("typeAliasSecondaryConstructor.kt") public void testTypeAliasSecondaryConstructor() throws Exception { runTest("compiler/testData/codegen/box/typealias/typeAliasSecondaryConstructor.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/unaryOp") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class UnaryOp extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class UnaryOp { + @Test public void testAllFilesPresentInUnaryOp() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unaryOp"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("call.kt") public void testCall() throws Exception { runTest("compiler/testData/codegen/box/unaryOp/call.kt"); } + @Test @TestMetadata("callNullable.kt") public void testCallNullable() throws Exception { runTest("compiler/testData/codegen/box/unaryOp/callNullable.kt"); } + @Test @TestMetadata("callWithCommonType.kt") public void testCallWithCommonType() throws Exception { runTest("compiler/testData/codegen/box/unaryOp/callWithCommonType.kt"); } + @Test @TestMetadata("intrinsic.kt") public void testIntrinsic() throws Exception { runTest("compiler/testData/codegen/box/unaryOp/intrinsic.kt"); } + @Test @TestMetadata("intrinsicNullable.kt") public void testIntrinsicNullable() throws Exception { runTest("compiler/testData/codegen/box/unaryOp/intrinsicNullable.kt"); } + @Test @TestMetadata("longOverflow.kt") public void testLongOverflow() throws Exception { runTest("compiler/testData/codegen/box/unaryOp/longOverflow.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/underscoredTypeArguments") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class UnderscoredTypeArguments extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class UnderscoredTypeArguments { + @Test public void testAllFilesPresentInUnderscoredTypeArguments() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/underscoredTypeArguments"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("backTicked.kt") public void testBackTicked() throws Exception { runTest("compiler/testData/codegen/box/underscoredTypeArguments/backTicked.kt"); } + @Test @TestMetadata("lambdaInputType.kt") public void testLambdaInputType() throws Exception { runTest("compiler/testData/codegen/box/underscoredTypeArguments/lambdaInputType.kt"); } + @Test @TestMetadata("react.kt") public void testReact() throws Exception { runTest("compiler/testData/codegen/box/underscoredTypeArguments/react.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("compiler/testData/codegen/box/underscoredTypeArguments/simple.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/unit") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Unit extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Unit { + @Test public void testAllFilesPresentInUnit() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unit"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("closureReturnsNullableUnit.kt") public void testClosureReturnsNullableUnit() throws Exception { runTest("compiler/testData/codegen/box/unit/closureReturnsNullableUnit.kt"); } + @Test @TestMetadata("ifElse.kt") public void testIfElse() throws Exception { runTest("compiler/testData/codegen/box/unit/ifElse.kt"); } + @Test @TestMetadata("kt3634.kt") public void testKt3634() throws Exception { runTest("compiler/testData/codegen/box/unit/kt3634.kt"); } + @Test @TestMetadata("kt4212.kt") public void testKt4212() throws Exception { runTest("compiler/testData/codegen/box/unit/kt4212.kt"); } + @Test @TestMetadata("kt4265.kt") public void testKt4265() throws Exception { runTest("compiler/testData/codegen/box/unit/kt4265.kt"); } + @Test @TestMetadata("kt51036.kt") public void testKt51036() throws Exception { runTest("compiler/testData/codegen/box/unit/kt51036.kt"); } + @Test @TestMetadata("kt56723.kt") public void testKt56723() throws Exception { runTest("compiler/testData/codegen/box/unit/kt56723.kt"); } + @Test @TestMetadata("nullableUnit.kt") public void testNullableUnit() throws Exception { runTest("compiler/testData/codegen/box/unit/nullableUnit.kt"); } + @Test @TestMetadata("nullableUnitInWhen1.kt") public void testNullableUnitInWhen1() throws Exception { runTest("compiler/testData/codegen/box/unit/nullableUnitInWhen1.kt"); } + @Test @TestMetadata("nullableUnitInWhen2.kt") public void testNullableUnitInWhen2() throws Exception { runTest("compiler/testData/codegen/box/unit/nullableUnitInWhen2.kt"); } + @Test @TestMetadata("nullableUnitInWhen3.kt") public void testNullableUnitInWhen3() throws Exception { runTest("compiler/testData/codegen/box/unit/nullableUnitInWhen3.kt"); } + @Test @TestMetadata("sillyThings.kt") public void testSillyThings() throws Exception { runTest("compiler/testData/codegen/box/unit/sillyThings.kt"); } + @Test @TestMetadata("unitClassObject.kt") public void testUnitClassObject() throws Exception { runTest("compiler/testData/codegen/box/unit/unitClassObject.kt"); } + @Test @TestMetadata("UnitValue.kt") public void testUnitValue() throws Exception { runTest("compiler/testData/codegen/box/unit/UnitValue.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/unsignedTypes") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class UnsignedTypes extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class UnsignedTypes { + @Test public void testAllFilesPresentInUnsignedTypes() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("boxConstValOfUnsignedType.kt") public void testBoxConstValOfUnsignedType() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/boxConstValOfUnsignedType.kt"); } + @Test @TestMetadata("boxedUnsignedEqualsZero.kt") public void testBoxedUnsignedEqualsZero() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/boxedUnsignedEqualsZero.kt"); } + @Test @TestMetadata("checkBasicUnsignedLiterals.kt") public void testCheckBasicUnsignedLiterals() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/checkBasicUnsignedLiterals.kt"); } + @Test @TestMetadata("defaultArguments.kt") public void testDefaultArguments() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/defaultArguments.kt"); } + @Test @TestMetadata("equalsImplForInlineClassWrappingNullableInlineClass.kt") public void testEqualsImplForInlineClassWrappingNullableInlineClass() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/equalsImplForInlineClassWrappingNullableInlineClass.kt"); } + @Test @TestMetadata("forEachIndexedInListOfUInts.kt") public void testForEachIndexedInListOfUInts() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/forEachIndexedInListOfUInts.kt"); } + @Test @TestMetadata("forInUnsignedDownTo.kt") public void testForInUnsignedDownTo() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/forInUnsignedDownTo.kt"); } + @Test @TestMetadata("forInUnsignedProgression.kt") public void testForInUnsignedProgression() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/forInUnsignedProgression.kt"); } + @Test @TestMetadata("forInUnsignedRange.kt") public void testForInUnsignedRange() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/forInUnsignedRange.kt"); } + @Test @TestMetadata("forInUnsignedRangeLiteral.kt") public void testForInUnsignedRangeLiteral() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/forInUnsignedRangeLiteral.kt"); } + @Test @TestMetadata("forInUnsignedRangeWithCoercion.kt") public void testForInUnsignedRangeWithCoercion() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/forInUnsignedRangeWithCoercion.kt"); } + @Test @TestMetadata("forInUnsignedUntil.kt") public void testForInUnsignedUntil() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/forInUnsignedUntil.kt"); } + @Test @TestMetadata("implicitIntegerCoercionNamedArg.kt") public void testImplicitIntegerCoercionNamedArg() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/implicitIntegerCoercionNamedArg.kt"); } + @Test @TestMetadata("inUnsignedDownTo.kt") public void testInUnsignedDownTo() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/inUnsignedDownTo.kt"); } + @Test @TestMetadata("inUnsignedRange.kt") public void testInUnsignedRange() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/inUnsignedRange.kt"); } + @Test @TestMetadata("inUnsignedRangeLiteral.kt") public void testInUnsignedRangeLiteral() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/inUnsignedRangeLiteral.kt"); } + @Test @TestMetadata("inUnsignedUntil.kt") public void testInUnsignedUntil() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/inUnsignedUntil.kt"); } + @Test @TestMetadata("iterateOverArrayOfUnsignedValues.kt") public void testIterateOverArrayOfUnsignedValues() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/iterateOverArrayOfUnsignedValues.kt"); } + @Test @TestMetadata("iterateOverListOfBoxedUnsignedValues.kt") public void testIterateOverListOfBoxedUnsignedValues() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/iterateOverListOfBoxedUnsignedValues.kt"); } + @Test @TestMetadata("kt25784.kt") public void testKt25784() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/kt25784.kt"); } + @Test @TestMetadata("kt43286.kt") public void testKt43286() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/kt43286.kt"); } + @Test @TestMetadata("kt43286a.kt") public void testKt43286a() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/kt43286a.kt"); } + @Test @TestMetadata("kt47716.kt") public void testKt47716() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/kt47716.kt"); } + @Test @TestMetadata("literalEqualsNullableUnsigned.kt") public void testLiteralEqualsNullableUnsigned() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/literalEqualsNullableUnsigned.kt"); } + @Test @TestMetadata("nullableUnsignedEqualsLiteral.kt") public void testNullableUnsignedEqualsLiteral() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/nullableUnsignedEqualsLiteral.kt"); } + @Test @TestMetadata("signedToUnsignedConversions.kt") public void testSignedToUnsignedConversions() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/signedToUnsignedConversions.kt"); } + @Test @TestMetadata("unsignedArraySize.kt") public void testUnsignedArraySize() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/unsignedArraySize.kt"); } + @Test @TestMetadata("unsignedIntCompare.kt") public void testUnsignedIntCompare() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/unsignedIntCompare.kt"); } + @Test @TestMetadata("unsignedIntDivide.kt") public void testUnsignedIntDivide() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/unsignedIntDivide.kt"); } + @Test @TestMetadata("unsignedIntRemainder.kt") public void testUnsignedIntRemainder() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/unsignedIntRemainder.kt"); } + @Test @TestMetadata("unsignedIntToString.kt") public void testUnsignedIntToString() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/unsignedIntToString.kt"); } + @Test @TestMetadata("unsignedLiteralsForMaxLongValue.kt") public void testUnsignedLiteralsForMaxLongValue() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/unsignedLiteralsForMaxLongValue.kt"); } + @Test @TestMetadata("unsignedLiteralsInApiVersion14.kt") public void testUnsignedLiteralsInApiVersion14() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/unsignedLiteralsInApiVersion14.kt"); } + @Test @TestMetadata("unsignedLiteralsWithSignedOverflow.kt") public void testUnsignedLiteralsWithSignedOverflow() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/unsignedLiteralsWithSignedOverflow.kt"); } + @Test @TestMetadata("unsignedLongCompare.kt") public void testUnsignedLongCompare() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/unsignedLongCompare.kt"); } + @Test @TestMetadata("unsignedLongDivide.kt") public void testUnsignedLongDivide() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/unsignedLongDivide.kt"); } + @Test @TestMetadata("unsignedLongRemainder.kt") public void testUnsignedLongRemainder() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/unsignedLongRemainder.kt"); } + @Test @TestMetadata("unsignedLongToString.kt") public void testUnsignedLongToString() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/unsignedLongToString.kt"); } + @Test @TestMetadata("unsignedRangeIterator.kt") public void testUnsignedRangeIterator() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/unsignedRangeIterator.kt"); } + @Test @TestMetadata("unsignedToSignedConversion.kt") public void testUnsignedToSignedConversion() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/unsignedToSignedConversion.kt"); } + @Test @TestMetadata("unsignedTypePrefixIncrementDecrementBoxing.kt") public void testUnsignedTypePrefixIncrementDecrementBoxing() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/unsignedTypePrefixIncrementDecrementBoxing.kt"); } + @Test @TestMetadata("unsignedTypeValuesInsideStringTemplates.kt") public void testUnsignedTypeValuesInsideStringTemplates() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/unsignedTypeValuesInsideStringTemplates.kt"); } + @Test @TestMetadata("varargsOfUnsignedTypes.kt") public void testVarargsOfUnsignedTypes() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/varargsOfUnsignedTypes.kt"); } + @Test @TestMetadata("whenByUnsigned.kt") public void testWhenByUnsigned() throws Exception { runTest("compiler/testData/codegen/box/unsignedTypes/whenByUnsigned.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/unsignedTypes/jvm8Intrinsics") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Jvm8Intrinsics extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Jvm8Intrinsics { + @Test public void testAllFilesPresentInJvm8Intrinsics() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes/jvm8Intrinsics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/valueClasses") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class ValueClasses extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class ValueClasses { + @Test public void testAllFilesPresentInValueClasses() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Nested @TestMetadata("compiler/testData/codegen/box/valueClasses/javaInterop") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class JavaInterop extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class JavaInterop { + @Test public void testAllFilesPresentInJavaInterop() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses/javaInterop"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } } + @Nested @TestMetadata("compiler/testData/codegen/box/vararg") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Vararg extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Vararg { + @Test public void testAllFilesPresentInVararg() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vararg"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("boxingArgumentsForVararg.kt") public void testBoxingArgumentsForVararg() throws Exception { runTest("compiler/testData/codegen/box/vararg/boxingArgumentsForVararg.kt"); } + @Test @TestMetadata("doNotCopyImmediatelyCreatedArrays.kt") public void testDoNotCopyImmediatelyCreatedArrays() throws Exception { runTest("compiler/testData/codegen/box/vararg/doNotCopyImmediatelyCreatedArrays.kt"); } + @Test @TestMetadata("evaluationOrder.kt") public void testEvaluationOrder() throws Exception { runTest("compiler/testData/codegen/box/vararg/evaluationOrder.kt"); } + @Test @TestMetadata("kt10926.kt") public void testKt10926() throws Exception { runTest("compiler/testData/codegen/box/vararg/kt10926.kt"); } + @Test @TestMetadata("kt1978.kt") public void testKt1978() throws Exception { runTest("compiler/testData/codegen/box/vararg/kt1978.kt"); } + @Test @TestMetadata("kt37715.kt") public void testKt37715() throws Exception { runTest("compiler/testData/codegen/box/vararg/kt37715.kt"); } + @Test @TestMetadata("kt37779.kt") public void testKt37779() throws Exception { runTest("compiler/testData/codegen/box/vararg/kt37779.kt"); } + @Test @TestMetadata("kt581.kt") public void testKt581() throws Exception { runTest("compiler/testData/codegen/box/vararg/kt581.kt"); } + @Test @TestMetadata("kt6192.kt") public void testKt6192() throws Exception { runTest("compiler/testData/codegen/box/vararg/kt6192.kt"); } + @Test @TestMetadata("kt796_797.kt") public void testKt796_797() throws Exception { runTest("compiler/testData/codegen/box/vararg/kt796_797.kt"); } + @Test @TestMetadata("referenceToContainsFromVarargParameter.kt") public void testReferenceToContainsFromVarargParameter() throws Exception { runTest("compiler/testData/codegen/box/vararg/referenceToContainsFromVarargParameter.kt"); } + @Test @TestMetadata("singleAssignmentToVarargsInFunction.kt") public void testSingleAssignmentToVarargsInFunction() throws Exception { runTest("compiler/testData/codegen/box/vararg/singleAssignmentToVarargsInFunction.kt"); } + @Test @TestMetadata("spreadCopiesArray.kt") public void testSpreadCopiesArray() throws Exception { runTest("compiler/testData/codegen/box/vararg/spreadCopiesArray.kt"); } + @Test @TestMetadata("useSuspendFunResultAsVararg.kt") public void testUseSuspendFunResultAsVararg() throws Exception { runTest("compiler/testData/codegen/box/vararg/useSuspendFunResultAsVararg.kt"); } + @Test @TestMetadata("varargInFunParam.kt") public void testVarargInFunParam() throws Exception { runTest("compiler/testData/codegen/box/vararg/varargInFunParam.kt"); } + @Test @TestMetadata("varargsAndFunctionLiterals.kt") public void testVarargsAndFunctionLiterals() throws Exception { runTest("compiler/testData/codegen/box/vararg/varargsAndFunctionLiterals.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/volatile") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Volatile extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Volatile { + @Test public void testAllFilesPresentInVolatile() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/volatile"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("volatileBool.kt") public void testVolatileBool() throws Exception { runTest("compiler/testData/codegen/box/volatile/volatileBool.kt"); } + @Test @TestMetadata("volatileByte.kt") public void testVolatileByte() throws Exception { runTest("compiler/testData/codegen/box/volatile/volatileByte.kt"); } + @Test @TestMetadata("volatileDouble.kt") public void testVolatileDouble() throws Exception { runTest("compiler/testData/codegen/box/volatile/volatileDouble.kt"); } + @Test @TestMetadata("volatileFloat.kt") public void testVolatileFloat() throws Exception { runTest("compiler/testData/codegen/box/volatile/volatileFloat.kt"); } + @Test @TestMetadata("volatileGeneric.kt") public void testVolatileGeneric() throws Exception { runTest("compiler/testData/codegen/box/volatile/volatileGeneric.kt"); } + @Test @TestMetadata("volatileInt.kt") public void testVolatileInt() throws Exception { runTest("compiler/testData/codegen/box/volatile/volatileInt.kt"); } + @Test @TestMetadata("volatileLong.kt") public void testVolatileLong() throws Exception { runTest("compiler/testData/codegen/box/volatile/volatileLong.kt"); } + @Test @TestMetadata("volatileShort.kt") public void testVolatileShort() throws Exception { runTest("compiler/testData/codegen/box/volatile/volatileShort.kt"); } + @Test @TestMetadata("volatileString.kt") public void testVolatileString() throws Exception { runTest("compiler/testData/codegen/box/volatile/volatileString.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/when") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class When extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class When { + @Test public void testAllFilesPresentInWhen() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("callProperty.kt") public void testCallProperty() throws Exception { runTest("compiler/testData/codegen/box/when/callProperty.kt"); } + @Test @TestMetadata("edgeCases.kt") public void testEdgeCases() throws Exception { runTest("compiler/testData/codegen/box/when/edgeCases.kt"); } + @Test @TestMetadata("emptyWhen.kt") public void testEmptyWhen() throws Exception { runTest("compiler/testData/codegen/box/when/emptyWhen.kt"); } + @Test @TestMetadata("exceptionOnNoMatch.kt") public void testExceptionOnNoMatch() throws Exception { runTest("compiler/testData/codegen/box/when/exceptionOnNoMatch.kt"); } + @Test @TestMetadata("exhaustiveBoolean.kt") public void testExhaustiveBoolean() throws Exception { runTest("compiler/testData/codegen/box/when/exhaustiveBoolean.kt"); } + @Test @TestMetadata("exhaustiveBreakContinue.kt") public void testExhaustiveBreakContinue() throws Exception { runTest("compiler/testData/codegen/box/when/exhaustiveBreakContinue.kt"); } + @Test @TestMetadata("exhaustiveWhenInitialization.kt") public void testExhaustiveWhenInitialization() throws Exception { runTest("compiler/testData/codegen/box/when/exhaustiveWhenInitialization.kt"); } + @Test @TestMetadata("exhaustiveWhenReturn.kt") public void testExhaustiveWhenReturn() throws Exception { runTest("compiler/testData/codegen/box/when/exhaustiveWhenReturn.kt"); } + @Test @TestMetadata("implicitExhaustiveAndReturn.kt") public void testImplicitExhaustiveAndReturn() throws Exception { runTest("compiler/testData/codegen/box/when/implicitExhaustiveAndReturn.kt"); } + @Test @TestMetadata("inferredTypeParameters.kt") public void testInferredTypeParameters() throws Exception { runTest("compiler/testData/codegen/box/when/inferredTypeParameters.kt"); } + @Test @TestMetadata("integralWhenWithNoInlinedConstants2.kt") public void testIntegralWhenWithNoInlinedConstants2() throws Exception { runTest("compiler/testData/codegen/box/when/integralWhenWithNoInlinedConstants2.kt"); } + @Test @TestMetadata("is.kt") public void testIs() throws Exception { runTest("compiler/testData/codegen/box/when/is.kt"); } + @Test @TestMetadata("kt2457.kt") public void testKt2457() throws Exception { runTest("compiler/testData/codegen/box/when/kt2457.kt"); } + @Test @TestMetadata("kt2466.kt") public void testKt2466() throws Exception { runTest("compiler/testData/codegen/box/when/kt2466.kt"); } + @Test @TestMetadata("kt45081.kt") public void testKt45081() throws Exception { runTest("compiler/testData/codegen/box/when/kt45081.kt"); } + @Test @TestMetadata("kt47365.kt") public void testKt47365() throws Exception { runTest("compiler/testData/codegen/box/when/kt47365.kt"); } + @Test @TestMetadata("kt5307.kt") public void testKt5307() throws Exception { runTest("compiler/testData/codegen/box/when/kt5307.kt"); } + @Test @TestMetadata("kt5448.kt") public void testKt5448() throws Exception { runTest("compiler/testData/codegen/box/when/kt5448.kt"); } + @Test @TestMetadata("kt55993.kt") public void testKt55993() throws Exception { runTest("compiler/testData/codegen/box/when/kt55993.kt"); } + @Test @TestMetadata("kt59346.kt") public void testKt59346() throws Exception { runTest("compiler/testData/codegen/box/when/kt59346.kt"); } + @Test @TestMetadata("longInRange.kt") public void testLongInRange() throws Exception { runTest("compiler/testData/codegen/box/when/longInRange.kt"); } + @Test @TestMetadata("matchNotNullAgainstNullable.kt") public void testMatchNotNullAgainstNullable() throws Exception { runTest("compiler/testData/codegen/box/when/matchNotNullAgainstNullable.kt"); } + @Test @TestMetadata("multipleEntries.kt") public void testMultipleEntries() throws Exception { runTest("compiler/testData/codegen/box/when/multipleEntries.kt"); } + @Test @TestMetadata("noElseCoerceToUnit.kt") public void testNoElseCoerceToUnit() throws Exception { runTest("compiler/testData/codegen/box/when/noElseCoerceToUnit.kt"); } + @Test @TestMetadata("noElseExhaustive.kt") public void testNoElseExhaustive() throws Exception { runTest("compiler/testData/codegen/box/when/noElseExhaustive.kt"); } + @Test @TestMetadata("noElseExhaustiveStatement.kt") public void testNoElseExhaustiveStatement() throws Exception { runTest("compiler/testData/codegen/box/when/noElseExhaustiveStatement.kt"); } + @Test @TestMetadata("noElseExhaustiveUnitExpected.kt") public void testNoElseExhaustiveUnitExpected() throws Exception { runTest("compiler/testData/codegen/box/when/noElseExhaustiveUnitExpected.kt"); } + @Test @TestMetadata("noElseInStatement.kt") public void testNoElseInStatement() throws Exception { runTest("compiler/testData/codegen/box/when/noElseInStatement.kt"); } + @Test @TestMetadata("noElseNoMatch.kt") public void testNoElseNoMatch() throws Exception { runTest("compiler/testData/codegen/box/when/noElseNoMatch.kt"); } + @Test @TestMetadata("nullableWhen.kt") public void testNullableWhen() throws Exception { runTest("compiler/testData/codegen/box/when/nullableWhen.kt"); } + @Test @TestMetadata("range.kt") public void testRange() throws Exception { runTest("compiler/testData/codegen/box/when/range.kt"); } + @Test @TestMetadata("sealedWhenInitialization.kt") public void testSealedWhenInitialization() throws Exception { runTest("compiler/testData/codegen/box/when/sealedWhenInitialization.kt"); } + @Test @TestMetadata("switchBreakNoLabel.kt") public void testSwitchBreakNoLabel() throws Exception { runTest("compiler/testData/codegen/box/when/switchBreakNoLabel.kt"); } + @Test @TestMetadata("switchOptimizationDense.kt") public void testSwitchOptimizationDense() throws Exception { runTest("compiler/testData/codegen/box/when/switchOptimizationDense.kt"); } + @Test @TestMetadata("switchOptimizationDuplicates.kt") public void testSwitchOptimizationDuplicates() throws Exception { runTest("compiler/testData/codegen/box/when/switchOptimizationDuplicates.kt"); } + @Test @TestMetadata("switchOptimizationMultipleConditions.kt") public void testSwitchOptimizationMultipleConditions() throws Exception { runTest("compiler/testData/codegen/box/when/switchOptimizationMultipleConditions.kt"); } + @Test @TestMetadata("switchOptimizationMultipleMixedConditions.kt") public void testSwitchOptimizationMultipleMixedConditions() throws Exception { runTest("compiler/testData/codegen/box/when/switchOptimizationMultipleMixedConditions.kt"); } + @Test @TestMetadata("switchOptimizationSingleStatementCase.kt") public void testSwitchOptimizationSingleStatementCase() throws Exception { runTest("compiler/testData/codegen/box/when/switchOptimizationSingleStatementCase.kt"); } + @Test @TestMetadata("switchOptimizationSparse.kt") public void testSwitchOptimizationSparse() throws Exception { runTest("compiler/testData/codegen/box/when/switchOptimizationSparse.kt"); } + @Test @TestMetadata("switchOptimizationStatement.kt") public void testSwitchOptimizationStatement() throws Exception { runTest("compiler/testData/codegen/box/when/switchOptimizationStatement.kt"); } + @Test @TestMetadata("switchOptimizationTypes.kt") public void testSwitchOptimizationTypes() throws Exception { runTest("compiler/testData/codegen/box/when/switchOptimizationTypes.kt"); } + @Test @TestMetadata("switchOptimizationUnordered.kt") public void testSwitchOptimizationUnordered() throws Exception { runTest("compiler/testData/codegen/box/when/switchOptimizationUnordered.kt"); } + @Test @TestMetadata("switchOptimizationWithGap.kt") public void testSwitchOptimizationWithGap() throws Exception { runTest("compiler/testData/codegen/box/when/switchOptimizationWithGap.kt"); } + @Test @TestMetadata("typeDisjunction.kt") public void testTypeDisjunction() throws Exception { runTest("compiler/testData/codegen/box/when/typeDisjunction.kt"); } + @Test @TestMetadata("whenArgumentIsEvaluatedOnlyOnce.kt") public void testWhenArgumentIsEvaluatedOnlyOnce() throws Exception { runTest("compiler/testData/codegen/box/when/whenArgumentIsEvaluatedOnlyOnce.kt"); } + @Test @TestMetadata("whenSafeCallSubjectEvaluatedOnce.kt") public void testWhenSafeCallSubjectEvaluatedOnce() throws Exception { runTest("compiler/testData/codegen/box/when/whenSafeCallSubjectEvaluatedOnce.kt"); } + @Nested @TestMetadata("compiler/testData/codegen/box/when/enumOptimization") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class EnumOptimization extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class EnumOptimization { + @Test public void testAllFilesPresentInEnumOptimization() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/enumOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("bigEnum.kt") public void testBigEnum() throws Exception { runTest("compiler/testData/codegen/box/when/enumOptimization/bigEnum.kt"); } + @Test @TestMetadata("differentEnumClasses.kt") public void testDifferentEnumClasses() throws Exception { runTest("compiler/testData/codegen/box/when/enumOptimization/differentEnumClasses.kt"); } + @Test @TestMetadata("differentEnumClasses2.kt") public void testDifferentEnumClasses2() throws Exception { runTest("compiler/testData/codegen/box/when/enumOptimization/differentEnumClasses2.kt"); } + @Test @TestMetadata("duplicatingItems.kt") public void testDuplicatingItems() throws Exception { runTest("compiler/testData/codegen/box/when/enumOptimization/duplicatingItems.kt"); } + @Test @TestMetadata("enumInsideClassObject.kt") public void testEnumInsideClassObject() throws Exception { runTest("compiler/testData/codegen/box/when/enumOptimization/enumInsideClassObject.kt"); } + @Test @TestMetadata("expression.kt") public void testExpression() throws Exception { runTest("compiler/testData/codegen/box/when/enumOptimization/expression.kt"); } + @Test @TestMetadata("functionLiteralInTopLevel.kt") public void testFunctionLiteralInTopLevel() throws Exception { runTest("compiler/testData/codegen/box/when/enumOptimization/functionLiteralInTopLevel.kt"); } + @Test @TestMetadata("kt14597.kt") public void testKt14597() throws Exception { runTest("compiler/testData/codegen/box/when/enumOptimization/kt14597.kt"); } + @Test @TestMetadata("kt14597_full.kt") public void testKt14597_full() throws Exception { runTest("compiler/testData/codegen/box/when/enumOptimization/kt14597_full.kt"); } + @Test @TestMetadata("kt14802.kt") public void testKt14802() throws Exception { runTest("compiler/testData/codegen/box/when/enumOptimization/kt14802.kt"); } + @Test @TestMetadata("kt15806.kt") public void testKt15806() throws Exception { runTest("compiler/testData/codegen/box/when/enumOptimization/kt15806.kt"); } + @Test @TestMetadata("kt50258.kt") public void testKt50258() throws Exception { runTest("compiler/testData/codegen/box/when/enumOptimization/kt50258.kt"); } + @Test @TestMetadata("manyWhensWithinClass.kt") public void testManyWhensWithinClass() throws Exception { runTest("compiler/testData/codegen/box/when/enumOptimization/manyWhensWithinClass.kt"); } + @Test @TestMetadata("nestedWhenInCondition.kt") public void testNestedWhenInCondition() throws Exception { runTest("compiler/testData/codegen/box/when/enumOptimization/nestedWhenInCondition.kt"); } + @Test @TestMetadata("nestedWhenInResult.kt") public void testNestedWhenInResult() throws Exception { runTest("compiler/testData/codegen/box/when/enumOptimization/nestedWhenInResult.kt"); } + @Test @TestMetadata("nonConstantEnum.kt") public void testNonConstantEnum() throws Exception { runTest("compiler/testData/codegen/box/when/enumOptimization/nonConstantEnum.kt"); } + @Test @TestMetadata("nullIsTheFirstEntry.kt") public void testNullIsTheFirstEntry() throws Exception { runTest("compiler/testData/codegen/box/when/enumOptimization/nullIsTheFirstEntry.kt"); } + @Test @TestMetadata("nullability.kt") public void testNullability() throws Exception { runTest("compiler/testData/codegen/box/when/enumOptimization/nullability.kt"); } + @Test @TestMetadata("nullableEnum.kt") public void testNullableEnum() throws Exception { runTest("compiler/testData/codegen/box/when/enumOptimization/nullableEnum.kt"); } + @Test @TestMetadata("subjectAny.kt") public void testSubjectAny() throws Exception { runTest("compiler/testData/codegen/box/when/enumOptimization/subjectAny.kt"); } + @Test @TestMetadata("withoutElse.kt") public void testWithoutElse() throws Exception { runTest("compiler/testData/codegen/box/when/enumOptimization/withoutElse.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/when/stringOptimization") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class StringOptimization extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class StringOptimization { + @Test public void testAllFilesPresentInStringOptimization() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/stringOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("duplicatingItems.kt") public void testDuplicatingItems() throws Exception { runTest("compiler/testData/codegen/box/when/stringOptimization/duplicatingItems.kt"); } + @Test @TestMetadata("duplicatingItemsSameHashCode.kt") public void testDuplicatingItemsSameHashCode() throws Exception { runTest("compiler/testData/codegen/box/when/stringOptimization/duplicatingItemsSameHashCode.kt"); } + @Test @TestMetadata("duplicatingItemsSameHashCode2.kt") public void testDuplicatingItemsSameHashCode2() throws Exception { runTest("compiler/testData/codegen/box/when/stringOptimization/duplicatingItemsSameHashCode2.kt"); } + @Test @TestMetadata("duplicatingItemsSameHashCode3.kt") public void testDuplicatingItemsSameHashCode3() throws Exception { runTest("compiler/testData/codegen/box/when/stringOptimization/duplicatingItemsSameHashCode3.kt"); } + @Test @TestMetadata("expression.kt") public void testExpression() throws Exception { runTest("compiler/testData/codegen/box/when/stringOptimization/expression.kt"); } + @Test @TestMetadata("nullability.kt") public void testNullability() throws Exception { runTest("compiler/testData/codegen/box/when/stringOptimization/nullability.kt"); } + @Test @TestMetadata("sameHashCode.kt") public void testSameHashCode() throws Exception { runTest("compiler/testData/codegen/box/when/stringOptimization/sameHashCode.kt"); } + @Test @TestMetadata("statement.kt") public void testStatement() throws Exception { runTest("compiler/testData/codegen/box/when/stringOptimization/statement.kt"); } + @Test @TestMetadata("temporaryVarInWhenByStringIsDisposedProperly.kt") public void testTemporaryVarInWhenByStringIsDisposedProperly() throws Exception { runTest("compiler/testData/codegen/box/when/stringOptimization/temporaryVarInWhenByStringIsDisposedProperly.kt"); } } + @Nested @TestMetadata("compiler/testData/codegen/box/when/whenSubjectVariable") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class WhenSubjectVariable extends AbstractIrCodegenBoxWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class WhenSubjectVariable { + @Test public void testAllFilesPresentInWhenSubjectVariable() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/whenSubjectVariable"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("captureSubjectVariable.kt") public void testCaptureSubjectVariable() throws Exception { runTest("compiler/testData/codegen/box/when/whenSubjectVariable/captureSubjectVariable.kt"); } + @Test @TestMetadata("denseIntSwitchWithSubjectVariable.kt") public void testDenseIntSwitchWithSubjectVariable() throws Exception { runTest("compiler/testData/codegen/box/when/whenSubjectVariable/denseIntSwitchWithSubjectVariable.kt"); } + @Test @TestMetadata("equalityWithSubjectVariable.kt") public void testEqualityWithSubjectVariable() throws Exception { runTest("compiler/testData/codegen/box/when/whenSubjectVariable/equalityWithSubjectVariable.kt"); } + @Test @TestMetadata("ieee754Equality.kt") public void testIeee754Equality() throws Exception { runTest("compiler/testData/codegen/box/when/whenSubjectVariable/ieee754Equality.kt"); } + @Test @TestMetadata("ieee754EqualityWithSmartCast.kt") public void testIeee754EqualityWithSmartCast() throws Exception { runTest("compiler/testData/codegen/box/when/whenSubjectVariable/ieee754EqualityWithSmartCast.kt"); } + @Test @TestMetadata("isCheckOnSubjectVariable.kt") public void testIsCheckOnSubjectVariable() throws Exception { runTest("compiler/testData/codegen/box/when/whenSubjectVariable/isCheckOnSubjectVariable.kt"); } + @Test @TestMetadata("kt27161.kt") public void testKt27161() throws Exception { runTest("compiler/testData/codegen/box/when/whenSubjectVariable/kt27161.kt"); } + @Test @TestMetadata("kt27161_int.kt") public void testKt27161_int() throws Exception { runTest("compiler/testData/codegen/box/when/whenSubjectVariable/kt27161_int.kt"); } + @Test @TestMetadata("kt27161_nested.kt") public void testKt27161_nested() throws Exception { runTest("compiler/testData/codegen/box/when/whenSubjectVariable/kt27161_nested.kt"); } + @Test @TestMetadata("kt27161_nested2.kt") public void testKt27161_nested2() throws Exception { runTest("compiler/testData/codegen/box/when/whenSubjectVariable/kt27161_nested2.kt"); } + @Test @TestMetadata("kt27161_string.kt") public void testKt27161_string() throws Exception { runTest("compiler/testData/codegen/box/when/whenSubjectVariable/kt27161_string.kt"); } + @Test @TestMetadata("kt33641_inlineClass.kt") public void testKt33641_inlineClass() throws Exception { runTest("compiler/testData/codegen/box/when/whenSubjectVariable/kt33641_inlineClass.kt"); } + @Test @TestMetadata("rangeCheckOnSubjectVariable.kt") public void testRangeCheckOnSubjectVariable() throws Exception { runTest("compiler/testData/codegen/box/when/whenSubjectVariable/rangeCheckOnSubjectVariable.kt"); } + @Test @TestMetadata("sparseIntSwitchWithSubjectVariable.kt") public void testSparseIntSwitchWithSubjectVariable() throws Exception { runTest("compiler/testData/codegen/box/when/whenSubjectVariable/sparseIntSwitchWithSubjectVariable.kt"); } + @Test @TestMetadata("subjectExpressionIsEvaluatedOnce.kt") public void testSubjectExpressionIsEvaluatedOnce() throws Exception { runTest("compiler/testData/codegen/box/when/whenSubjectVariable/subjectExpressionIsEvaluatedOnce.kt"); } + @Test @TestMetadata("whenByEnum.kt") public void testWhenByEnum() throws Exception { runTest("compiler/testData/codegen/box/when/whenSubjectVariable/whenByEnum.kt"); } + @Test @TestMetadata("whenByNullableEnum.kt") public void testWhenByNullableEnum() throws Exception { runTest("compiler/testData/codegen/box/when/whenSubjectVariable/whenByNullableEnum.kt"); } + @Test @TestMetadata("whenByString.kt") public void testWhenByString() throws Exception { runTest("compiler/testData/codegen/box/when/whenSubjectVariable/whenByString.kt"); diff --git a/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/IrCodegenWasmJsInteropWasmTestGenerated.java b/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/FirWasmCodegenWasmJsInteropTestGenerated.java similarity index 91% rename from wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/IrCodegenWasmJsInteropWasmTestGenerated.java rename to wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/FirWasmCodegenWasmJsInteropTestGenerated.java index fa30a2bd275..6138fcdd515 100644 --- a/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/IrCodegenWasmJsInteropWasmTestGenerated.java +++ b/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/FirWasmCodegenWasmJsInteropTestGenerated.java @@ -6,12 +6,11 @@ package org.jetbrains.kotlin.wasm.test; import com.intellij.testFramework.TestDataPath; -import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; -import org.jetbrains.kotlin.test.KotlinTestUtils; import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; import java.io.File; import java.util.regex.Pattern; @@ -20,121 +19,139 @@ import java.util.regex.Pattern; @SuppressWarnings("all") @TestMetadata("compiler/testData/codegen/boxWasmJsInterop") @TestDataPath("$PROJECT_ROOT") -@RunWith(JUnit3RunnerWithInners.class) -public class IrCodegenWasmJsInteropWasmTestGenerated extends AbstractIrCodegenWasmJsInteropWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - +public class FirWasmCodegenWasmJsInteropTestGenerated extends AbstractFirWasmCodegenWasmJsInteropTest { + @Test public void testAllFilesPresentInBoxWasmJsInterop() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxWasmJsInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("callingWasmDirectly.kt") public void testCallingWasmDirectly() throws Exception { runTest("compiler/testData/codegen/boxWasmJsInterop/callingWasmDirectly.kt"); } + @Test @TestMetadata("defaultValues.kt") public void testDefaultValues() throws Exception { runTest("compiler/testData/codegen/boxWasmJsInterop/defaultValues.kt"); } + @Test @TestMetadata("externalTypeOperators.kt") public void testExternalTypeOperators() throws Exception { runTest("compiler/testData/codegen/boxWasmJsInterop/externalTypeOperators.kt"); } + @Test @TestMetadata("externals.kt") public void testExternals() throws Exception { runTest("compiler/testData/codegen/boxWasmJsInterop/externals.kt"); } + @Test @TestMetadata("functionTypes.kt") public void testFunctionTypes() throws Exception { runTest("compiler/testData/codegen/boxWasmJsInterop/functionTypes.kt"); } + @Test @TestMetadata("imperativeWrapperInitialised.kt") public void testImperativeWrapperInitialised() throws Exception { runTest("compiler/testData/codegen/boxWasmJsInterop/imperativeWrapperInitialised.kt"); } + @Test @TestMetadata("imperativeWrapperUninitialised.kt") public void testImperativeWrapperUninitialised() throws Exception { runTest("compiler/testData/codegen/boxWasmJsInterop/imperativeWrapperUninitialised.kt"); } + @Test @TestMetadata("jsCode.kt") public void testJsCode() throws Exception { runTest("compiler/testData/codegen/boxWasmJsInterop/jsCode.kt"); } + @Test @TestMetadata("jsExport.kt") public void testJsExport() throws Exception { runTest("compiler/testData/codegen/boxWasmJsInterop/jsExport.kt"); } + @Test @TestMetadata("jsModule.kt") public void testJsModule() throws Exception { runTest("compiler/testData/codegen/boxWasmJsInterop/jsModule.kt"); } + @Test @TestMetadata("jsModuleWithQualifier.kt") public void testJsModuleWithQualifier() throws Exception { runTest("compiler/testData/codegen/boxWasmJsInterop/jsModuleWithQualifier.kt"); } + @Test @TestMetadata("jsQualifier.kt") public void testJsQualifier() throws Exception { runTest("compiler/testData/codegen/boxWasmJsInterop/jsQualifier.kt"); } + @Test @TestMetadata("jsToKotlinAdapters.kt") public void testJsToKotlinAdapters() throws Exception { runTest("compiler/testData/codegen/boxWasmJsInterop/jsToKotlinAdapters.kt"); } + @Test @TestMetadata("jsTypes.kt") public void testJsTypes() throws Exception { runTest("compiler/testData/codegen/boxWasmJsInterop/jsTypes.kt"); } + @Test @TestMetadata("kotlinToJsAdapters.kt") public void testKotlinToJsAdapters() throws Exception { runTest("compiler/testData/codegen/boxWasmJsInterop/kotlinToJsAdapters.kt"); } + @Test @TestMetadata("lambdaAdapterNameClash.kt") public void testLambdaAdapterNameClash() throws Exception { runTest("compiler/testData/codegen/boxWasmJsInterop/lambdaAdapterNameClash.kt"); } + @Test @TestMetadata("longStrings.kt") public void testLongStrings() throws Exception { runTest("compiler/testData/codegen/boxWasmJsInterop/longStrings.kt"); } + @Test @TestMetadata("nameClash.kt") public void testNameClash() throws Exception { runTest("compiler/testData/codegen/boxWasmJsInterop/nameClash.kt"); } + @Test @TestMetadata("nullableExternRefs.kt") public void testNullableExternRefs() throws Exception { runTest("compiler/testData/codegen/boxWasmJsInterop/nullableExternRefs.kt"); } + @Test @TestMetadata("types.kt") public void testTypes() throws Exception { runTest("compiler/testData/codegen/boxWasmJsInterop/types.kt"); } + @Test @TestMetadata("vararg.kt") public void testVararg() throws Exception { runTest("compiler/testData/codegen/boxWasmJsInterop/vararg.kt"); } + @Test @TestMetadata("wasmImport.kt") public void testWasmImport() throws Exception { runTest("compiler/testData/codegen/boxWasmJsInterop/wasmImport.kt"); diff --git a/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/FirWasmJsTranslatorTestGenerated.java b/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/FirWasmJsTranslatorTestGenerated.java new file mode 100644 index 00000000000..cb45c5aed7d --- /dev/null +++ b/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/FirWasmJsTranslatorTestGenerated.java @@ -0,0 +1,474 @@ +/* + * Copyright 2010-2023 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.wasm.test; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.TargetBackend; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.GenerateWasmTestsKt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +public class FirWasmJsTranslatorTestGenerated extends AbstractFirWasmJsTranslatorTest { + @Nested + @TestMetadata("js/js.translator/testData/box/main") + @TestDataPath("$PROJECT_ROOT") + public class Main { + @Test + public void testAllFilesPresentInMain() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/main"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("differentMains.kt") + public void testDifferentMains() throws Exception { + runTest("js/js.translator/testData/box/main/differentMains.kt"); + } + + @Test + @TestMetadata("incremental.kt") + public void testIncremental() throws Exception { + runTest("js/js.translator/testData/box/main/incremental.kt"); + } + + @Test + @TestMetadata("noArgs.kt") + public void testNoArgs() throws Exception { + runTest("js/js.translator/testData/box/main/noArgs.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("js/js.translator/testData/box/main/simple.kt"); + } + + @Test + @TestMetadata("suspendMain.kt") + public void testSuspendMain() throws Exception { + runTest("js/js.translator/testData/box/main/suspendMain.kt"); + } + + @Test + @TestMetadata("suspendMainNoArgs.kt") + public void testSuspendMainNoArgs() throws Exception { + runTest("js/js.translator/testData/box/main/suspendMainNoArgs.kt"); + } + + @Test + @TestMetadata("suspendMainThrows.kt") + public void testSuspendMainThrows() throws Exception { + runTest("js/js.translator/testData/box/main/suspendMainThrows.kt"); + } + + @Test + @TestMetadata("twoMains.kt") + public void testTwoMains() throws Exception { + runTest("js/js.translator/testData/box/main/twoMains.kt"); + } + } + + @Nested + @TestMetadata("js/js.translator/testData/box/native") + @TestDataPath("$PROJECT_ROOT") + public class Native { + @Test + @TestMetadata("accessToCompanionObjectFromInlineFun.kt") + public void testAccessToCompanionObjectFromInlineFun() throws Exception { + runTest("js/js.translator/testData/box/native/accessToCompanionObjectFromInlineFun.kt"); + } + + @Test + public void testAllFilesPresentInNative() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/native"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("castToNativeClassChecked.kt") + public void testCastToNativeClassChecked() throws Exception { + runTest("js/js.translator/testData/box/native/castToNativeClassChecked.kt"); + } + + @Test + @TestMetadata("castToNativeInterface.kt") + public void testCastToNativeInterface() throws Exception { + runTest("js/js.translator/testData/box/native/castToNativeInterface.kt"); + } + + @Test + @TestMetadata("castToNativeInterfaceChecked.kt") + public void testCastToNativeInterfaceChecked() throws Exception { + runTest("js/js.translator/testData/box/native/castToNativeInterfaceChecked.kt"); + } + + @Test + @TestMetadata("castToNullableNativeInterface.kt") + public void testCastToNullableNativeInterface() throws Exception { + runTest("js/js.translator/testData/box/native/castToNullableNativeInterface.kt"); + } + + @Test + @TestMetadata("castToTypeParamBoundedByNativeInterface.kt") + public void testCastToTypeParamBoundedByNativeInterface() throws Exception { + runTest("js/js.translator/testData/box/native/castToTypeParamBoundedByNativeInterface.kt"); + } + + @Test + @TestMetadata("class.kt") + public void testClass() throws Exception { + runTest("js/js.translator/testData/box/native/class.kt"); + } + + @Test + @TestMetadata("classObject.kt") + public void testClassObject() throws Exception { + runTest("js/js.translator/testData/box/native/classObject.kt"); + } + + @Test + @TestMetadata("externalValWithOverridenVar.kt") + public void testExternalValWithOverridenVar() throws Exception { + runTest("js/js.translator/testData/box/native/externalValWithOverridenVar.kt"); + } + + @Test + @TestMetadata("kt2209.kt") + public void testKt2209() throws Exception { + runTest("js/js.translator/testData/box/native/kt2209.kt"); + } + + @Test + @TestMetadata("nestedElements.kt") + public void testNestedElements() throws Exception { + runTest("js/js.translator/testData/box/native/nestedElements.kt"); + } + + @Test + @TestMetadata("objectFunWithVararg.kt") + public void testObjectFunWithVararg() throws Exception { + runTest("js/js.translator/testData/box/native/objectFunWithVararg.kt"); + } + + @Test + @TestMetadata("passExtLambdaToNative.kt") + public void testPassExtLambdaToNative() throws Exception { + runTest("js/js.translator/testData/box/native/passExtLambdaToNative.kt"); + } + + @Test + @TestMetadata("passMemberOrExtFromNative.kt") + public void testPassMemberOrExtFromNative() throws Exception { + runTest("js/js.translator/testData/box/native/passMemberOrExtFromNative.kt"); + } + + @Test + @TestMetadata("passMemberOrExtToNative.kt") + public void testPassMemberOrExtToNative() throws Exception { + runTest("js/js.translator/testData/box/native/passMemberOrExtToNative.kt"); + } + + @Test + @TestMetadata("passTopLevelFunctionFromNative.kt") + public void testPassTopLevelFunctionFromNative() throws Exception { + runTest("js/js.translator/testData/box/native/passTopLevelFunctionFromNative.kt"); + } + + @Test + @TestMetadata("passTopLevelOrLocalFunctionToNative.kt") + public void testPassTopLevelOrLocalFunctionToNative() throws Exception { + runTest("js/js.translator/testData/box/native/passTopLevelOrLocalFunctionToNative.kt"); + } + + @Test + @TestMetadata("privateExternal.kt") + public void testPrivateExternal() throws Exception { + runTest("js/js.translator/testData/box/native/privateExternal.kt"); + } + + @Test + @TestMetadata("safeCastToNativeInterface.kt") + public void testSafeCastToNativeInterface() throws Exception { + runTest("js/js.translator/testData/box/native/safeCastToNativeInterface.kt"); + } + + @Test + @TestMetadata("secondaryConstructor.kt") + public void testSecondaryConstructor() throws Exception { + runTest("js/js.translator/testData/box/native/secondaryConstructor.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("js/js.translator/testData/box/native/simple.kt"); + } + + @Test + @TestMetadata("simpleUndefined.kt") + public void testSimpleUndefined() throws Exception { + runTest("js/js.translator/testData/box/native/simpleUndefined.kt"); + } + + @Test + @TestMetadata("useClassFromInlineFun.kt") + public void testUseClassFromInlineFun() throws Exception { + runTest("js/js.translator/testData/box/native/useClassFromInlineFun.kt"); + } + + @Test + @TestMetadata("vararg.kt") + public void testVararg() throws Exception { + runTest("js/js.translator/testData/box/native/vararg.kt"); + } + } + + @Nested + @TestMetadata("js/js.translator/testData/box/esModules") + @TestDataPath("$PROJECT_ROOT") + public class EsModules { + @Test + public void testAllFilesPresentInEsModules() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/esModules"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true, "jsExport", "native", "export", "crossModuleRef", "crossModuleRefPerFile", "crossModuleRefPerModule"); + } + + @Nested + @TestMetadata("js/js.translator/testData/box/esModules/incremental") + @TestDataPath("$PROJECT_ROOT") + public class Incremental { + @Test + public void testAllFilesPresentInIncremental() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/esModules/incremental"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("jsModule.kt") + public void testJsModule() throws Exception { + runTest("js/js.translator/testData/box/esModules/incremental/jsModule.kt"); + } + } + + @Nested + @TestMetadata("js/js.translator/testData/box/esModules/inline") + @TestDataPath("$PROJECT_ROOT") + public class Inline { + @Test + public void testAllFilesPresentInInline() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/esModules/inline"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("js/js.translator/testData/box/esModules/jsModule") + @TestDataPath("$PROJECT_ROOT") + public class JsModule { + @Test + public void testAllFilesPresentInJsModule() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/esModules/jsModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("externalClass.kt") + public void testExternalClass() throws Exception { + runTest("js/js.translator/testData/box/esModules/jsModule/externalClass.kt"); + } + + @Test + @TestMetadata("externalClassNameClash.kt") + public void testExternalClassNameClash() throws Exception { + runTest("js/js.translator/testData/box/esModules/jsModule/externalClassNameClash.kt"); + } + + @Test + @TestMetadata("externalFunction.kt") + public void testExternalFunction() throws Exception { + runTest("js/js.translator/testData/box/esModules/jsModule/externalFunction.kt"); + } + + @Test + @TestMetadata("externalFunctionNameClash.kt") + public void testExternalFunctionNameClash() throws Exception { + runTest("js/js.translator/testData/box/esModules/jsModule/externalFunctionNameClash.kt"); + } + + @Test + @TestMetadata("externalObject.kt") + public void testExternalObject() throws Exception { + runTest("js/js.translator/testData/box/esModules/jsModule/externalObject.kt"); + } + + @Test + @TestMetadata("externalPackage.kt") + public void testExternalPackage() throws Exception { + runTest("js/js.translator/testData/box/esModules/jsModule/externalPackage.kt"); + } + + @Test + @TestMetadata("externalPackageInDifferentFile.kt") + public void testExternalPackageInDifferentFile() throws Exception { + runTest("js/js.translator/testData/box/esModules/jsModule/externalPackageInDifferentFile.kt"); + } + + @Test + @TestMetadata("externalProperty.kt") + public void testExternalProperty() throws Exception { + runTest("js/js.translator/testData/box/esModules/jsModule/externalProperty.kt"); + } + + @Test + @TestMetadata("interfaces.kt") + public void testInterfaces() throws Exception { + runTest("js/js.translator/testData/box/esModules/jsModule/interfaces.kt"); + } + + @Test + @TestMetadata("topLevelVarargFun.kt") + public void testTopLevelVarargFun() throws Exception { + runTest("js/js.translator/testData/box/esModules/jsModule/topLevelVarargFun.kt"); + } + } + + @Nested + @TestMetadata("js/js.translator/testData/box/esModules/jsName") + @TestDataPath("$PROJECT_ROOT") + public class JsName { + @Test + public void testAllFilesPresentInJsName() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/esModules/jsName"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("defaultJsName.kt") + public void testDefaultJsName() throws Exception { + runTest("js/js.translator/testData/box/esModules/jsName/defaultJsName.kt"); + } + + @Test + @TestMetadata("jsTopLevelClashes.kt") + public void testJsTopLevelClashes() throws Exception { + runTest("js/js.translator/testData/box/esModules/jsName/jsTopLevelClashes.kt"); + } + } + } + + @Nested + @TestMetadata("js/js.translator/testData/box/jsQualifier") + @TestDataPath("$PROJECT_ROOT") + public class JsQualifier { + @Test + public void testAllFilesPresentInJsQualifier() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsQualifier"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("classes.kt") + public void testClasses() throws Exception { + runTest("js/js.translator/testData/box/jsQualifier/classes.kt"); + } + + @Test + @TestMetadata("interfaces.kt") + public void testInterfaces() throws Exception { + runTest("js/js.translator/testData/box/jsQualifier/interfaces.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("js/js.translator/testData/box/jsQualifier/simple.kt"); + } + } + + @Nested + @TestMetadata("js/js.translator/testData/box/reflection") + @TestDataPath("$PROJECT_ROOT") + public class Reflection { + @Test + public void testAllFilesPresentInReflection() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/reflection"), Pattern.compile("^(findAssociatedObject(InSeparatedFile)?)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("findAssociatedObject.kt") + public void testFindAssociatedObject() throws Exception { + runTest("js/js.translator/testData/box/reflection/findAssociatedObject.kt"); + } + + @Test + @TestMetadata("findAssociatedObjectInSeparatedFile.kt") + public void testFindAssociatedObjectInSeparatedFile() throws Exception { + runTest("js/js.translator/testData/box/reflection/findAssociatedObjectInSeparatedFile.kt"); + } + } + + @Nested + @TestMetadata("js/js.translator/testData/box/kotlin.test") + @TestDataPath("$PROJECT_ROOT") + public class Kotlin_test { + @Test + public void testAllFilesPresentInKotlin_test() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/kotlin.test"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("beforeAfter.kt") + public void testBeforeAfter() throws Exception { + runTest("js/js.translator/testData/box/kotlin.test/beforeAfter.kt"); + } + + @Test + @TestMetadata("ignore.kt") + public void testIgnore() throws Exception { + runTest("js/js.translator/testData/box/kotlin.test/ignore.kt"); + } + + @Test + @TestMetadata("illegalParameters.kt") + public void testIllegalParameters() throws Exception { + runTest("js/js.translator/testData/box/kotlin.test/illegalParameters.kt"); + } + + @Test + @TestMetadata("incremental.kt") + public void testIncremental() throws Exception { + runTest("js/js.translator/testData/box/kotlin.test/incremental.kt"); + } + + @Test + @TestMetadata("inherited.kt") + public void testInherited() throws Exception { + runTest("js/js.translator/testData/box/kotlin.test/inherited.kt"); + } + + @Test + @TestMetadata("mpp.kt") + public void testMpp() throws Exception { + runTest("js/js.translator/testData/box/kotlin.test/mpp.kt"); + } + + @Test + @TestMetadata("nested.kt") + public void testNested() throws Exception { + runTest("js/js.translator/testData/box/kotlin.test/nested.kt"); + } + + @Test + @TestMetadata("returnTestResult.kt") + public void testReturnTestResult() throws Exception { + runTest("js/js.translator/testData/box/kotlin.test/returnTestResult.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("js/js.translator/testData/box/kotlin.test/simple.kt"); + } + } +} diff --git a/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/JsTranslatorUnitWasmTestGenerated.java b/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/JsTranslatorUnitWasmTestGenerated.java deleted file mode 100644 index 19573eefbd8..00000000000 --- a/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/JsTranslatorUnitWasmTestGenerated.java +++ /dev/null @@ -1,77 +0,0 @@ -/* - * Copyright 2010-2023 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.wasm.test; - -import com.intellij.testFramework.TestDataPath; -import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; -import org.jetbrains.kotlin.test.KotlinTestUtils; -import org.jetbrains.kotlin.test.util.KtTestUtil; -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.GenerateWasmTestsKt}. DO NOT MODIFY MANUALLY */ -@SuppressWarnings("all") -@TestMetadata("js/js.translator/testData/box/kotlin.test") -@TestDataPath("$PROJECT_ROOT") -@RunWith(JUnit3RunnerWithInners.class) -public class JsTranslatorUnitWasmTestGenerated extends AbstractJsTranslatorUnitWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - - public void testAllFilesPresentInKotlin_test() throws Exception { - KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/kotlin.test"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); - } - - @TestMetadata("beforeAfter.kt") - public void testBeforeAfter() throws Exception { - runTest("js/js.translator/testData/box/kotlin.test/beforeAfter.kt"); - } - - @TestMetadata("ignore.kt") - public void testIgnore() throws Exception { - runTest("js/js.translator/testData/box/kotlin.test/ignore.kt"); - } - - @TestMetadata("illegalParameters.kt") - public void testIllegalParameters() throws Exception { - runTest("js/js.translator/testData/box/kotlin.test/illegalParameters.kt"); - } - - @TestMetadata("incremental.kt") - public void testIncremental() throws Exception { - runTest("js/js.translator/testData/box/kotlin.test/incremental.kt"); - } - - @TestMetadata("inherited.kt") - public void testInherited() throws Exception { - runTest("js/js.translator/testData/box/kotlin.test/inherited.kt"); - } - - @TestMetadata("mpp.kt") - public void testMpp() throws Exception { - runTest("js/js.translator/testData/box/kotlin.test/mpp.kt"); - } - - @TestMetadata("nested.kt") - public void testNested() throws Exception { - runTest("js/js.translator/testData/box/kotlin.test/nested.kt"); - } - - @TestMetadata("returnTestResult.kt") - public void testReturnTestResult() throws Exception { - runTest("js/js.translator/testData/box/kotlin.test/returnTestResult.kt"); - } - - @TestMetadata("simple.kt") - public void testSimple() throws Exception { - runTest("js/js.translator/testData/box/kotlin.test/simple.kt"); - } -} diff --git a/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/K1WasmCodegenBoxInlineTestGenerated.java b/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/K1WasmCodegenBoxInlineTestGenerated.java new file mode 100644 index 00000000000..88684f822cb --- /dev/null +++ b/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/K1WasmCodegenBoxInlineTestGenerated.java @@ -0,0 +1,5123 @@ +/* + * Copyright 2010-2023 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.wasm.test; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.TargetBackend; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.GenerateWasmTestsKt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("compiler/testData/codegen/boxInline") +@TestDataPath("$PROJECT_ROOT") +public class K1WasmCodegenBoxInlineTestGenerated extends AbstractK1WasmCodegenBoxInlineTest { + @Test + public void testAllFilesPresentInBoxInline() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/annotations") + @TestDataPath("$PROJECT_ROOT") + public class Annotations { + @Test + public void testAllFilesPresentInAnnotations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/annotations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("annotationInstanceInlining.kt") + public void testAnnotationInstanceInlining() throws Exception { + runTest("compiler/testData/codegen/boxInline/annotations/annotationInstanceInlining.kt"); + } + + @Test + @TestMetadata("instanceInAnonymousClass.kt") + public void testInstanceInAnonymousClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/annotations/instanceInAnonymousClass.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject") + @TestDataPath("$PROJECT_ROOT") + public class AnonymousObject { + @Test + public void testAllFilesPresentInAnonymousObject() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("anonymousObjectInCallChildren.kt") + public void testAnonymousObjectInCallChildren() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectInCallChildren.kt"); + } + + @Test + @TestMetadata("anonymousObjectInDefault.kt") + public void testAnonymousObjectInDefault() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectInDefault.kt"); + } + + @Test + @TestMetadata("anonymousObjectOnCallSite.kt") + public void testAnonymousObjectOnCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectOnCallSite.kt"); + } + + @Test + @TestMetadata("anonymousObjectOnCallSiteSuperParams.kt") + public void testAnonymousObjectOnCallSiteSuperParams() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectOnCallSiteSuperParams.kt"); + } + + @Test + @TestMetadata("anonymousObjectOnDeclarationSite.kt") + public void testAnonymousObjectOnDeclarationSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectOnDeclarationSite.kt"); + } + + @Test + @TestMetadata("anonymousObjectOnDeclarationSiteSuperParams.kt") + public void testAnonymousObjectOnDeclarationSiteSuperParams() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/anonymousObjectOnDeclarationSiteSuperParams.kt"); + } + + @Test + @TestMetadata("capturedLambdaInInline.kt") + public void testCapturedLambdaInInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/capturedLambdaInInline.kt"); + } + + @Test + @TestMetadata("capturedLambdaInInline2.kt") + public void testCapturedLambdaInInline2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/capturedLambdaInInline2.kt"); + } + + @Test + @TestMetadata("capturedLambdaInInline3.kt") + public void testCapturedLambdaInInline3() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/capturedLambdaInInline3.kt"); + } + + @Test + @TestMetadata("capturedLambdaInInlineObject.kt") + public void testCapturedLambdaInInlineObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/capturedLambdaInInlineObject.kt"); + } + + @Test + @TestMetadata("capturedLocalFun.kt") + public void testCapturedLocalFun() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/capturedLocalFun.kt"); + } + + @Test + @TestMetadata("capturedLocalFunRef.kt") + public void testCapturedLocalFunRef() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/capturedLocalFunRef.kt"); + } + + @Test + @TestMetadata("changingReturnType.kt") + public void testChangingReturnType() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/changingReturnType.kt"); + } + + @Test + @TestMetadata("constructOriginalInRegenerated.kt") + public void testConstructOriginalInRegenerated() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/constructOriginalInRegenerated.kt"); + } + + @Test + @TestMetadata("constructorVisibility.kt") + public void testConstructorVisibility() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/constructorVisibility.kt"); + } + + @Test + @TestMetadata("constructorVisibilityInConstLambda.kt") + public void testConstructorVisibilityInConstLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/constructorVisibilityInConstLambda.kt"); + } + + @Test + @TestMetadata("constructorVisibilityInLambda.kt") + public void testConstructorVisibilityInLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/constructorVisibilityInLambda.kt"); + } + + @Test + @TestMetadata("defineClass.kt") + public void testDefineClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/defineClass.kt"); + } + + @Test + @TestMetadata("fakeOverrideInDefaultMultiModule.kt") + public void testFakeOverrideInDefaultMultiModule() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/fakeOverrideInDefaultMultiModule.kt"); + } + + @Test + @TestMetadata("fakeOverrideMultiModule.kt") + public void testFakeOverrideMultiModule() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/fakeOverrideMultiModule.kt"); + } + + @Test + @TestMetadata("functionExpression.kt") + public void testFunctionExpression() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/functionExpression.kt"); + } + + @Test + @TestMetadata("inlineCallInsideInlineLambda.kt") + public void testInlineCallInsideInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/inlineCallInsideInlineLambda.kt"); + } + + @Test + @TestMetadata("kt13182.kt") + public void testKt13182() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt13182.kt"); + } + + @Test + @TestMetadata("kt13374.kt") + public void testKt13374() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt13374.kt"); + } + + @Test + @TestMetadata("kt14011.kt") + public void testKt14011() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt14011.kt"); + } + + @Test + @TestMetadata("kt14011_2.kt") + public void testKt14011_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt14011_2.kt"); + } + + @Test + @TestMetadata("kt14011_3.kt") + public void testKt14011_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt14011_3.kt"); + } + + @Test + @TestMetadata("kt15751.kt") + public void testKt15751() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt15751.kt"); + } + + @Test + @TestMetadata("kt17972.kt") + public void testKt17972() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972.kt"); + } + + @Test + @TestMetadata("kt17972_2.kt") + public void testKt17972_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_2.kt"); + } + + @Test + @TestMetadata("kt17972_3.kt") + public void testKt17972_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_3.kt"); + } + + @Test + @TestMetadata("kt17972_4.kt") + public void testKt17972_4() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_4.kt"); + } + + @Test + @TestMetadata("kt17972_5.kt") + public void testKt17972_5() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_5.kt"); + } + + @Test + @TestMetadata("kt17972_super.kt") + public void testKt17972_super() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_super.kt"); + } + + @Test + @TestMetadata("kt17972_super2.kt") + public void testKt17972_super2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_super2.kt"); + } + + @Test + @TestMetadata("kt17972_super3.kt") + public void testKt17972_super3() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt17972_super3.kt"); + } + + @Test + @TestMetadata("kt19389.kt") + public void testKt19389() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt19389.kt"); + } + + @Test + @TestMetadata("kt19399.kt") + public void testKt19399() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt19399.kt"); + } + + @Test + @TestMetadata("kt19723.kt") + public void testKt19723() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt19723.kt"); + } + + @Test + @TestMetadata("kt34656.kt") + public void testKt34656() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt34656.kt"); + } + + @Test + @TestMetadata("kt38197.kt") + public void testKt38197() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt38197.kt"); + } + + @Test + @TestMetadata("kt42815.kt") + public void testKt42815() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt42815.kt"); + } + + @Test + @TestMetadata("kt42815_delegated.kt") + public void testKt42815_delegated() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt42815_delegated.kt"); + } + + @Test + @TestMetadata("kt51950.kt") + public void testKt51950() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt51950.kt"); + } + + @Test + @TestMetadata("kt52795.kt") + public void testKt52795() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt52795.kt"); + } + + @Test + @TestMetadata("kt52795_2.kt") + public void testKt52795_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt52795_2.kt"); + } + + @Test + @TestMetadata("kt52795_3.kt") + public void testKt52795_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt52795_3.kt"); + } + + @Test + @TestMetadata("kt52795_4.kt") + public void testKt52795_4() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt52795_4.kt"); + } + + @Test + @TestMetadata("kt52795_5.kt") + public void testKt52795_5() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt52795_5.kt"); + } + + @Test + @TestMetadata("kt57053.kt") + public void testKt57053() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt57053.kt"); + } + + @Test + @TestMetadata("kt6007.kt") + public void testKt6007() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt6007.kt"); + } + + @Test + @TestMetadata("kt6552.kt") + public void testKt6552() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt6552.kt"); + } + + @Test + @TestMetadata("kt8133.kt") + public void testKt8133() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt8133.kt"); + } + + @Test + @TestMetadata("kt9064.kt") + public void testKt9064() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt9064.kt"); + } + + @Test + @TestMetadata("kt9064v2.kt") + public void testKt9064v2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt9064v2.kt"); + } + + @Test + @TestMetadata("kt9591.kt") + public void testKt9591() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt9591.kt"); + } + + @Test + @TestMetadata("kt9877.kt") + public void testKt9877() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt9877.kt"); + } + + @Test + @TestMetadata("kt9877_2.kt") + public void testKt9877_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/kt9877_2.kt"); + } + + @Test + @TestMetadata("objectInLambdaCapturesAnotherObject.kt") + public void testObjectInLambdaCapturesAnotherObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/objectInLambdaCapturesAnotherObject.kt"); + } + + @Test + @TestMetadata("safeCall.kt") + public void testSafeCall() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/safeCall.kt"); + } + + @Test + @TestMetadata("safeCall_2.kt") + public void testSafeCall_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/safeCall_2.kt"); + } + + @Test + @TestMetadata("sharedFromCrossinline.kt") + public void testSharedFromCrossinline() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/sharedFromCrossinline.kt"); + } + + @Test + @TestMetadata("superConstructorWithObjectParameter.kt") + public void testSuperConstructorWithObjectParameter() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/superConstructorWithObjectParameter.kt"); + } + + @Test + @TestMetadata("typeInfo.kt") + public void testTypeInfo() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/typeInfo.kt"); + } + + @Test + @TestMetadata("withInlineMethod.kt") + public void testWithInlineMethod() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/withInlineMethod.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject/enumEntries") + @TestDataPath("$PROJECT_ROOT") + public class EnumEntries { + @Test + public void testAllFilesPresentInEnumEntries() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumEntries"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject/enumWhen") + @TestDataPath("$PROJECT_ROOT") + public class EnumWhen { + @Test + public void testAllFilesPresentInEnumWhen() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/enumWhen"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("callSite.kt") + public void testCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/enumWhen/callSite.kt"); + } + + @Test + @TestMetadata("declSite.kt") + public void testDeclSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/enumWhen/declSite.kt"); + } + + @Test + @TestMetadata("declSiteSeveralMappings.kt") + public void testDeclSiteSeveralMappings() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/enumWhen/declSiteSeveralMappings.kt"); + } + + @Test + @TestMetadata("declSiteSeveralMappingsDifOrder.kt") + public void testDeclSiteSeveralMappingsDifOrder() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/enumWhen/declSiteSeveralMappingsDifOrder.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing") + @TestDataPath("$PROJECT_ROOT") + public class ProperRecapturing { + @Test + public void testAllFilesPresentInProperRecapturing() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("inlineChain.kt") + public void testInlineChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing/inlineChain.kt"); + } + + @Test + @TestMetadata("lambdaChain.kt") + public void testLambdaChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing/lambdaChain.kt"); + } + + @Test + @TestMetadata("lambdaChainSimple.kt") + public void testLambdaChainSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing/lambdaChainSimple.kt"); + } + + @Test + @TestMetadata("lambdaChain_2.kt") + public void testLambdaChain_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing/lambdaChain_2.kt"); + } + + @Test + @TestMetadata("lambdaChain_3.kt") + public void testLambdaChain_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing/lambdaChain_3.kt"); + } + + @Test + @TestMetadata("noInlineLambda.kt") + public void testNoInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturing/noInlineLambda.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass") + @TestDataPath("$PROJECT_ROOT") + public class ProperRecapturingInClass { + @Test + public void testAllFilesPresentInProperRecapturingInClass() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("inlineChain.kt") + public void testInlineChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/inlineChain.kt"); + } + + @Test + @TestMetadata("inlinelambdaChain.kt") + public void testInlinelambdaChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/inlinelambdaChain.kt"); + } + + @Test + @TestMetadata("lambdaChain.kt") + public void testLambdaChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/lambdaChain.kt"); + } + + @Test + @TestMetadata("lambdaChainSimple.kt") + public void testLambdaChainSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/lambdaChainSimple.kt"); + } + + @Test + @TestMetadata("lambdaChainSimple_2.kt") + public void testLambdaChainSimple_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/lambdaChainSimple_2.kt"); + } + + @Test + @TestMetadata("lambdaChain_2.kt") + public void testLambdaChain_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/lambdaChain_2.kt"); + } + + @Test + @TestMetadata("lambdaChain_3.kt") + public void testLambdaChain_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/lambdaChain_3.kt"); + } + + @Test + @TestMetadata("noCapturedThisOnCallSite.kt") + public void testNoCapturedThisOnCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/noCapturedThisOnCallSite.kt"); + } + + @Test + @TestMetadata("noInlineLambda.kt") + public void testNoInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/noInlineLambda.kt"); + } + + @Test + @TestMetadata("twoInlineLambda.kt") + public void testTwoInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/twoInlineLambda.kt"); + } + + @Test + @TestMetadata("twoInlineLambdaComplex.kt") + public void testTwoInlineLambdaComplex() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/twoInlineLambdaComplex.kt"); + } + + @Test + @TestMetadata("twoInlineLambdaComplex_2.kt") + public void testTwoInlineLambdaComplex_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/properRecapturingInClass/twoInlineLambdaComplex_2.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject/sam") + @TestDataPath("$PROJECT_ROOT") + public class Sam { + @Test + public void testAllFilesPresentInSam() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers") + @TestDataPath("$PROJECT_ROOT") + public class TwoCapturedReceivers { + @Test + public void testAllFilesPresentInTwoCapturedReceivers() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt8668.kt") + public void testKt8668() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers/kt8668.kt"); + } + + @Test + @TestMetadata("kt8668_2.kt") + public void testKt8668_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers/kt8668_2.kt"); + } + + @Test + @TestMetadata("kt8668_3.kt") + public void testKt8668_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers/kt8668_3.kt"); + } + + @Test + @TestMetadata("kt8668_nested.kt") + public void testKt8668_nested() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers/kt8668_nested.kt"); + } + + @Test + @TestMetadata("kt8668_nested_2.kt") + public void testKt8668_nested_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers/kt8668_nested_2.kt"); + } + + @Test + @TestMetadata("twoDifferentDispatchReceivers.kt") + public void testTwoDifferentDispatchReceivers() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers/twoDifferentDispatchReceivers.kt"); + } + + @Test + @TestMetadata("twoExtensionReceivers.kt") + public void testTwoExtensionReceivers() throws Exception { + runTest("compiler/testData/codegen/boxInline/anonymousObject/twoCapturedReceivers/twoExtensionReceivers.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/argumentOrder") + @TestDataPath("$PROJECT_ROOT") + public class ArgumentOrder { + @Test + public void testAllFilesPresentInArgumentOrder() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/argumentOrder"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("boundFunctionReference.kt") + public void testBoundFunctionReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/boundFunctionReference.kt"); + } + + @Test + @TestMetadata("boundFunctionReference2.kt") + public void testBoundFunctionReference2() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/boundFunctionReference2.kt"); + } + + @Test + @TestMetadata("captured.kt") + public void testCaptured() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/captured.kt"); + } + + @Test + @TestMetadata("capturedInExtension.kt") + public void testCapturedInExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/capturedInExtension.kt"); + } + + @Test + @TestMetadata("defaultParametersAndLastVararg.kt") + public void testDefaultParametersAndLastVararg() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/defaultParametersAndLastVararg.kt"); + } + + @Test + @TestMetadata("defaultParametersAndLastVarargWithCorrectOrder.kt") + public void testDefaultParametersAndLastVarargWithCorrectOrder() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/defaultParametersAndLastVarargWithCorrectOrder.kt"); + } + + @Test + @TestMetadata("extension.kt") + public void testExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/extension.kt"); + } + + @Test + @TestMetadata("extensionInClass.kt") + public void testExtensionInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/extensionInClass.kt"); + } + + @Test + @TestMetadata("lambdaMigration.kt") + public void testLambdaMigration() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/lambdaMigration.kt"); + } + + @Test + @TestMetadata("lambdaMigrationInClass.kt") + public void testLambdaMigrationInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/lambdaMigrationInClass.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/simple.kt"); + } + + @Test + @TestMetadata("simpleInClass.kt") + public void testSimpleInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/simpleInClass.kt"); + } + + @Test + @TestMetadata("varargAndDefaultParameters.kt") + public void testVarargAndDefaultParameters() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/varargAndDefaultParameters.kt"); + } + + @Test + @TestMetadata("varargAndDefaultParametersWithCorrectOrder.kt") + public void testVarargAndDefaultParametersWithCorrectOrder() throws Exception { + runTest("compiler/testData/codegen/boxInline/argumentOrder/varargAndDefaultParametersWithCorrectOrder.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/arrayConvention") + @TestDataPath("$PROJECT_ROOT") + public class ArrayConvention { + @Test + public void testAllFilesPresentInArrayConvention() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/arrayConvention"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("simpleAccess.kt") + public void testSimpleAccess() throws Exception { + runTest("compiler/testData/codegen/boxInline/arrayConvention/simpleAccess.kt"); + } + + @Test + @TestMetadata("simpleAccessInClass.kt") + public void testSimpleAccessInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/arrayConvention/simpleAccessInClass.kt"); + } + + @Test + @TestMetadata("simpleAccessWithDefault.kt") + public void testSimpleAccessWithDefault() throws Exception { + runTest("compiler/testData/codegen/boxInline/arrayConvention/simpleAccessWithDefault.kt"); + } + + @Test + @TestMetadata("simpleAccessWithDefaultInClass.kt") + public void testSimpleAccessWithDefaultInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/arrayConvention/simpleAccessWithDefaultInClass.kt"); + } + + @Test + @TestMetadata("simpleAccessWithLambda.kt") + public void testSimpleAccessWithLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/arrayConvention/simpleAccessWithLambda.kt"); + } + + @Test + @TestMetadata("simpleAccessWithLambdaInClass.kt") + public void testSimpleAccessWithLambdaInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/arrayConvention/simpleAccessWithLambdaInClass.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/assert") + @TestDataPath("$PROJECT_ROOT") + public class Assert { + @Test + public void testAllFilesPresentInAssert() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/assert"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/builders") + @TestDataPath("$PROJECT_ROOT") + public class Builders { + @Test + public void testAllFilesPresentInBuilders() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/builders"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/bytecodePreprocessing") + @TestDataPath("$PROJECT_ROOT") + public class BytecodePreprocessing { + @Test + public void testAllFilesPresentInBytecodePreprocessing() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/bytecodePreprocessing"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/callableReference") + @TestDataPath("$PROJECT_ROOT") + public class CallableReference { + @Test + @TestMetadata("adapted.kt") + public void testAdapted() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/adapted.kt"); + } + + @Test + public void testAllFilesPresentInCallableReference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("classLevel.kt") + public void testClassLevel() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/classLevel.kt"); + } + + @Test + @TestMetadata("classLevel2.kt") + public void testClassLevel2() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/classLevel2.kt"); + } + + @Test + @TestMetadata("constructor.kt") + public void testConstructor() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/constructor.kt"); + } + + @Test + @TestMetadata("inlineCallableReference.kt") + public void testInlineCallableReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/inlineCallableReference.kt"); + } + + @Test + @TestMetadata("innerGenericConstuctor.kt") + public void testInnerGenericConstuctor() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/innerGenericConstuctor.kt"); + } + + @Test + @TestMetadata("intrinsic.kt") + public void testIntrinsic() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/intrinsic.kt"); + } + + @Test + @TestMetadata("kt15449.kt") + public void testKt15449() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/kt15449.kt"); + } + + @Test + @TestMetadata("kt15751_2.kt") + public void testKt15751_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/kt15751_2.kt"); + } + + @Test + @TestMetadata("kt16411.kt") + public void testKt16411() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/kt16411.kt"); + } + + @Test + @TestMetadata("kt35101.kt") + public void testKt35101() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/kt35101.kt"); + } + + @Test + @TestMetadata("propertyIntrinsic.kt") + public void testPropertyIntrinsic() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/propertyIntrinsic.kt"); + } + + @Test + @TestMetadata("propertyReference.kt") + public void testPropertyReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/propertyReference.kt"); + } + + @Test + @TestMetadata("topLevel.kt") + public void testTopLevel() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/topLevel.kt"); + } + + @Test + @TestMetadata("topLevelExtension.kt") + public void testTopLevelExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/topLevelExtension.kt"); + } + + @Test + @TestMetadata("topLevelProperty.kt") + public void testTopLevelProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/topLevelProperty.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/callableReference/adaptedReferences") + @TestDataPath("$PROJECT_ROOT") + public class AdaptedReferences { + @Test + public void testAllFilesPresentInAdaptedReferences() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/adaptedReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("inlineBound.kt") + public void testInlineBound() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/adaptedReferences/inlineBound.kt"); + } + + @Test + @TestMetadata("inlineDefault.kt") + public void testInlineDefault() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/adaptedReferences/inlineDefault.kt"); + } + + @Test + @TestMetadata("inlineVararg.kt") + public void testInlineVararg() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/adaptedReferences/inlineVararg.kt"); + } + + @Test + @TestMetadata("inlineVarargAndDefault.kt") + public void testInlineVarargAndDefault() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/adaptedReferences/inlineVarargAndDefault.kt"); + } + + @Test + @TestMetadata("inlineVarargInts.kt") + public void testInlineVarargInts() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/adaptedReferences/inlineVarargInts.kt"); + } + + @Test + @TestMetadata("multipleCallableReferenceUsage.kt") + public void testMultipleCallableReferenceUsage() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/adaptedReferences/multipleCallableReferenceUsage.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/callableReference/bound") + @TestDataPath("$PROJECT_ROOT") + public class Bound { + @Test + public void testAllFilesPresentInBound() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/callableReference/bound"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("classProperty.kt") + public void testClassProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/classProperty.kt"); + } + + @Test + @TestMetadata("doubleBoundToThis.kt") + public void testDoubleBoundToThis() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/doubleBoundToThis.kt"); + } + + @Test + @TestMetadata("emptyLhsFunction.kt") + public void testEmptyLhsFunction() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/emptyLhsFunction.kt"); + } + + @Test + @TestMetadata("emptyLhsOnInlineProperty.kt") + public void testEmptyLhsOnInlineProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/emptyLhsOnInlineProperty.kt"); + } + + @Test + @TestMetadata("emptyLhsProperty.kt") + public void testEmptyLhsProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/emptyLhsProperty.kt"); + } + + @Test + @TestMetadata("expression.kt") + public void testExpression() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/expression.kt"); + } + + @Test + @TestMetadata("extensionReceiver.kt") + public void testExtensionReceiver() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/extensionReceiver.kt"); + } + + @Test + @TestMetadata("filter.kt") + public void testFilter() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/filter.kt"); + } + + @Test + @TestMetadata("inlineValueParameterInsteadOfReceiver.kt") + public void testInlineValueParameterInsteadOfReceiver() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/inlineValueParameterInsteadOfReceiver.kt"); + } + + @Test + @TestMetadata("innerGenericConstuctor.kt") + public void testInnerGenericConstuctor() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/innerGenericConstuctor.kt"); + } + + @Test + @TestMetadata("intrinsic.kt") + public void testIntrinsic() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/intrinsic.kt"); + } + + @Test + @TestMetadata("kt18728.kt") + public void testKt18728() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/kt18728.kt"); + } + + @Test + @TestMetadata("kt18728_2.kt") + public void testKt18728_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/kt18728_2.kt"); + } + + @Test + @TestMetadata("kt18728_3.kt") + public void testKt18728_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/kt18728_3.kt"); + } + + @Test + @TestMetadata("kt18728_4.kt") + public void testKt18728_4() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/kt18728_4.kt"); + } + + @Test + @TestMetadata("kt30933.kt") + public void testKt30933() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/kt30933.kt"); + } + + @Test + @TestMetadata("lambdaOnLhs.kt") + public void testLambdaOnLhs() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/lambdaOnLhs.kt"); + } + + @Test + @TestMetadata("map.kt") + public void testMap() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/map.kt"); + } + + @Test + @TestMetadata("mixed.kt") + public void testMixed() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/mixed.kt"); + } + + @Test + @TestMetadata("objectProperty.kt") + public void testObjectProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/objectProperty.kt"); + } + + @Test + @TestMetadata("propertyImportedFromObject.kt") + public void testPropertyImportedFromObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/propertyImportedFromObject.kt"); + } + + @Test + @TestMetadata("sideEffect.kt") + public void testSideEffect() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/sideEffect.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/simple.kt"); + } + + @Test + @TestMetadata("simpleVal.kt") + public void testSimpleVal() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/simpleVal.kt"); + } + + @Test + @TestMetadata("simpleVal2.kt") + public void testSimpleVal2() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/simpleVal2.kt"); + } + + @Test + @TestMetadata("topLevelExtensionProperty.kt") + public void testTopLevelExtensionProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/callableReference/bound/topLevelExtensionProperty.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/capture") + @TestDataPath("$PROJECT_ROOT") + public class Capture { + @Test + public void testAllFilesPresentInCapture() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/capture"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("captureInlinable.kt") + public void testCaptureInlinable() throws Exception { + runTest("compiler/testData/codegen/boxInline/capture/captureInlinable.kt"); + } + + @Test + @TestMetadata("captureInlinableAndOther.kt") + public void testCaptureInlinableAndOther() throws Exception { + runTest("compiler/testData/codegen/boxInline/capture/captureInlinableAndOther.kt"); + } + + @Test + @TestMetadata("captureThisAndReceiver.kt") + public void testCaptureThisAndReceiver() throws Exception { + runTest("compiler/testData/codegen/boxInline/capture/captureThisAndReceiver.kt"); + } + + @Test + @TestMetadata("generics.kt") + public void testGenerics() throws Exception { + runTest("compiler/testData/codegen/boxInline/capture/generics.kt"); + } + + @Test + @TestMetadata("kt48230.kt") + public void testKt48230() throws Exception { + runTest("compiler/testData/codegen/boxInline/capture/kt48230.kt"); + } + + @Test + @TestMetadata("kt48230_2.kt") + public void testKt48230_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/capture/kt48230_2.kt"); + } + + @Test + @TestMetadata("kt56500.kt") + public void testKt56500() throws Exception { + runTest("compiler/testData/codegen/boxInline/capture/kt56500.kt"); + } + + @Test + @TestMetadata("kt56965.kt") + public void testKt56965() throws Exception { + runTest("compiler/testData/codegen/boxInline/capture/kt56965.kt"); + } + + @Test + @TestMetadata("kt56965_2.kt") + public void testKt56965_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/capture/kt56965_2.kt"); + } + + @Test + @TestMetadata("simpleCapturingInClass.kt") + public void testSimpleCapturingInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/capture/simpleCapturingInClass.kt"); + } + + @Test + @TestMetadata("simpleCapturingInPackage.kt") + public void testSimpleCapturingInPackage() throws Exception { + runTest("compiler/testData/codegen/boxInline/capture/simpleCapturingInPackage.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/complex") + @TestDataPath("$PROJECT_ROOT") + public class Complex { + @Test + public void testAllFilesPresentInComplex() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complex"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("closureChain.kt") + public void testClosureChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/complex/closureChain.kt"); + } + + @Test + @TestMetadata("kt44429.kt") + public void testKt44429() throws Exception { + runTest("compiler/testData/codegen/boxInline/complex/kt44429.kt"); + } + + @Test + @TestMetadata("swapAndWith.kt") + public void testSwapAndWith() throws Exception { + runTest("compiler/testData/codegen/boxInline/complex/swapAndWith.kt"); + } + + @Test + @TestMetadata("swapAndWith2.kt") + public void testSwapAndWith2() throws Exception { + runTest("compiler/testData/codegen/boxInline/complex/swapAndWith2.kt"); + } + + @Test + @TestMetadata("use.kt") + public void testUse() throws Exception { + runTest("compiler/testData/codegen/boxInline/complex/use.kt"); + } + + @Test + @TestMetadata("with.kt") + public void testWith() throws Exception { + runTest("compiler/testData/codegen/boxInline/complex/with.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/complexStack") + @TestDataPath("$PROJECT_ROOT") + public class ComplexStack { + @Test + public void testAllFilesPresentInComplexStack() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/complexStack"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("asCheck.kt") + public void testAsCheck() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/asCheck.kt"); + } + + @Test + @TestMetadata("asCheck2.kt") + public void testAsCheck2() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/asCheck2.kt"); + } + + @Test + @TestMetadata("breakContinueInInlineLambdaArgument.kt") + public void testBreakContinueInInlineLambdaArgument() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/breakContinueInInlineLambdaArgument.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/simple.kt"); + } + + @Test + @TestMetadata("simple2.kt") + public void testSimple2() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/simple2.kt"); + } + + @Test + @TestMetadata("simple3.kt") + public void testSimple3() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/simple3.kt"); + } + + @Test + @TestMetadata("simple4.kt") + public void testSimple4() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/simple4.kt"); + } + + @Test + @TestMetadata("simpleExtension.kt") + public void testSimpleExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/simpleExtension.kt"); + } + + @Test + @TestMetadata("spillConstructorArgumentsAndInlineLambdaParameter.kt") + public void testSpillConstructorArgumentsAndInlineLambdaParameter() throws Exception { + runTest("compiler/testData/codegen/boxInline/complexStack/spillConstructorArgumentsAndInlineLambdaParameter.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/contracts") + @TestDataPath("$PROJECT_ROOT") + public class Contracts { + @Test + public void testAllFilesPresentInContracts() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/contracts"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("cfgDependendValInitialization.kt") + public void testCfgDependendValInitialization() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/cfgDependendValInitialization.kt"); + } + + @Test + @TestMetadata("complexInitializer.kt") + public void testComplexInitializer() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/complexInitializer.kt"); + } + + @Test + @TestMetadata("complexInitializerWithStackTransformation.kt") + public void testComplexInitializerWithStackTransformation() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/complexInitializerWithStackTransformation.kt"); + } + + @Test + @TestMetadata("crossinlineCallableReference.kt") + public void testCrossinlineCallableReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/crossinlineCallableReference.kt"); + } + + @Test + @TestMetadata("definiteLongValInitialization.kt") + public void testDefiniteLongValInitialization() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/definiteLongValInitialization.kt"); + } + + @Test + @TestMetadata("definiteNestedValInitialization.kt") + public void testDefiniteNestedValInitialization() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/definiteNestedValInitialization.kt"); + } + + @Test + @TestMetadata("definiteValInitInInitializer.kt") + public void testDefiniteValInitInInitializer() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/definiteValInitInInitializer.kt"); + } + + @Test + @TestMetadata("definiteValInitialization.kt") + public void testDefiniteValInitialization() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/definiteValInitialization.kt"); + } + + @Test + @TestMetadata("exactlyOnceCrossinline.kt") + public void testExactlyOnceCrossinline() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/exactlyOnceCrossinline.kt"); + } + + @Test + @TestMetadata("exactlyOnceCrossinline2.kt") + public void testExactlyOnceCrossinline2() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/exactlyOnceCrossinline2.kt"); + } + + @Test + @TestMetadata("exactlyOnceNoinline.kt") + public void testExactlyOnceNoinline() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/exactlyOnceNoinline.kt"); + } + + @Test + @TestMetadata("nonLocalReturn.kt") + public void testNonLocalReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/nonLocalReturn.kt"); + } + + @Test + @TestMetadata("nonLocalReturnWithCycle.kt") + public void testNonLocalReturnWithCycle() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/nonLocalReturnWithCycle.kt"); + } + + @Test + @TestMetadata("propertyInitialization.kt") + public void testPropertyInitialization() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/propertyInitialization.kt"); + } + + @Test + @TestMetadata("valInitializationAndUsageInNestedLambda.kt") + public void testValInitializationAndUsageInNestedLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/contracts/valInitializationAndUsageInNestedLambda.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/defaultValues") + @TestDataPath("$PROJECT_ROOT") + public class DefaultValues { + @Test + @TestMetadata("33Parameters.kt") + public void test33Parameters() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/33Parameters.kt"); + } + + @Test + @TestMetadata("33ParametersInConstructor.kt") + public void test33ParametersInConstructor() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/33ParametersInConstructor.kt"); + } + + @Test + public void testAllFilesPresentInDefaultValues() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("defaultInExtension.kt") + public void testDefaultInExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/defaultInExtension.kt"); + } + + @Test + @TestMetadata("defaultMethod.kt") + public void testDefaultMethod() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/defaultMethod.kt"); + } + + @Test + @TestMetadata("defaultMethodInClass.kt") + public void testDefaultMethodInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/defaultMethodInClass.kt"); + } + + @Test + @TestMetadata("defaultParamRemapping.kt") + public void testDefaultParamRemapping() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/defaultParamRemapping.kt"); + } + + @Test + @TestMetadata("inlineInDefaultParameter.kt") + public void testInlineInDefaultParameter() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/inlineInDefaultParameter.kt"); + } + + @Test + @TestMetadata("inlineLambdaInNoInlineDefault.kt") + public void testInlineLambdaInNoInlineDefault() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/inlineLambdaInNoInlineDefault.kt"); + } + + @Test + @TestMetadata("kt11479.kt") + public void testKt11479() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt11479.kt"); + } + + @Test + @TestMetadata("kt11479InlinedDefaultParameter.kt") + public void testKt11479InlinedDefaultParameter() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt11479InlinedDefaultParameter.kt"); + } + + @Test + @TestMetadata("kt14564.kt") + public void testKt14564() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt14564.kt"); + } + + @Test + @TestMetadata("kt14564_2.kt") + public void testKt14564_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt14564_2.kt"); + } + + @Test + @TestMetadata("kt16496.kt") + public void testKt16496() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt16496.kt"); + } + + @Test + @TestMetadata("kt18689.kt") + public void testKt18689() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt18689.kt"); + } + + @Test + @TestMetadata("kt18689_2.kt") + public void testKt18689_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt18689_2.kt"); + } + + @Test + @TestMetadata("kt18689_3.kt") + public void testKt18689_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt18689_3.kt"); + } + + @Test + @TestMetadata("kt18689_4.kt") + public void testKt18689_4() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt18689_4.kt"); + } + + @Test + @TestMetadata("kt5685.kt") + public void testKt5685() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/kt5685.kt"); + } + + @Test + @TestMetadata("simpleDefaultMethod.kt") + public void testSimpleDefaultMethod() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/simpleDefaultMethod.kt"); + } + + @Test + @TestMetadata("varArgNoInline.kt") + public void testVarArgNoInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/varArgNoInline.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining") + @TestDataPath("$PROJECT_ROOT") + public class LambdaInlining { + @Test + public void testAllFilesPresentInLambdaInlining() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("checkLambdaClassIsPresent.kt") + public void testCheckLambdaClassIsPresent() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/checkLambdaClassIsPresent.kt"); + } + + @Test + @TestMetadata("checkLambdaClassesArePresent.kt") + public void testCheckLambdaClassesArePresent() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/checkLambdaClassesArePresent.kt"); + } + + @Test + @TestMetadata("checkObjectClassIsPresent.kt") + public void testCheckObjectClassIsPresent() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/checkObjectClassIsPresent.kt"); + } + + @Test + @TestMetadata("checkStaticLambdaClassIsPresent.kt") + public void testCheckStaticLambdaClassIsPresent() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/checkStaticLambdaClassIsPresent.kt"); + } + + @Test + @TestMetadata("checkStaticLambdaClassesArePresent.kt") + public void testCheckStaticLambdaClassesArePresent() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/checkStaticLambdaClassesArePresent.kt"); + } + + @Test + @TestMetadata("checkStaticObjectClassIsPresent.kt") + public void testCheckStaticObjectClassIsPresent() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/checkStaticObjectClassIsPresent.kt"); + } + + @Test + @TestMetadata("defaultAfterCapturing.kt") + public void testDefaultAfterCapturing() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/defaultAfterCapturing.kt"); + } + + @Test + @TestMetadata("defaultCallInDefaultLambda.kt") + public void testDefaultCallInDefaultLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/defaultCallInDefaultLambda.kt"); + } + + @Test + @TestMetadata("defaultLambdaInNoInline.kt") + public void testDefaultLambdaInNoInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/defaultLambdaInNoInline.kt"); + } + + @Test + @TestMetadata("differentInvokeSignature.kt") + public void testDifferentInvokeSignature() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/differentInvokeSignature.kt"); + } + + @Test + @TestMetadata("genericLambda.kt") + public void testGenericLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/genericLambda.kt"); + } + + @Test + @TestMetadata("instanceCapturedInClass.kt") + public void testInstanceCapturedInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/instanceCapturedInClass.kt"); + } + + @Test + @TestMetadata("instanceCapturedInInterface.kt") + public void testInstanceCapturedInInterface() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/instanceCapturedInInterface.kt"); + } + + @Test + @TestMetadata("kt21827.kt") + public void testKt21827() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/kt21827.kt"); + } + + @Test + @TestMetadata("kt21946.kt") + public void testKt21946() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/kt21946.kt"); + } + + @Test + @TestMetadata("kt24477.kt") + public void testKt24477() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/kt24477.kt"); + } + + @Test + @TestMetadata("kt25106.kt") + public void testKt25106() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/kt25106.kt"); + } + + @Test + @TestMetadata("lambdaTakesResult.kt") + public void testLambdaTakesResult() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/lambdaTakesResult.kt"); + } + + @Test + @TestMetadata("noInline.kt") + public void testNoInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/noInline.kt"); + } + + @Test + @TestMetadata("nonDefaultInlineInNoInline.kt") + public void testNonDefaultInlineInNoInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/nonDefaultInlineInNoInline.kt"); + } + + @Test + @TestMetadata("receiverClash.kt") + public void testReceiverClash() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/receiverClash.kt"); + } + + @Test + @TestMetadata("receiverClash2.kt") + public void testReceiverClash2() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/receiverClash2.kt"); + } + + @Test + @TestMetadata("receiverClashInClass.kt") + public void testReceiverClashInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/receiverClashInClass.kt"); + } + + @Test + @TestMetadata("receiverClashInClass2.kt") + public void testReceiverClashInClass2() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/receiverClashInClass2.kt"); + } + + @Test + @TestMetadata("reordering.kt") + public void testReordering() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/reordering.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/simple.kt"); + } + + @Test + @TestMetadata("simpleErased.kt") + public void testSimpleErased() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/simpleErased.kt"); + } + + @Test + @TestMetadata("simpleErasedStaticInstance.kt") + public void testSimpleErasedStaticInstance() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/simpleErasedStaticInstance.kt"); + } + + @Test + @TestMetadata("simpleExtension.kt") + public void testSimpleExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/simpleExtension.kt"); + } + + @Test + @TestMetadata("simpleGeneric.kt") + public void testSimpleGeneric() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/simpleGeneric.kt"); + } + + @Test + @TestMetadata("simpleStaticInstance.kt") + public void testSimpleStaticInstance() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/simpleStaticInstance.kt"); + } + + @Test + @TestMetadata("thisClash.kt") + public void testThisClash() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/thisClash.kt"); + } + + @Test + @TestMetadata("thisClashInClass.kt") + public void testThisClashInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/thisClashInClass.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences") + @TestDataPath("$PROJECT_ROOT") + public class CallableReferences { + @Test + public void testAllFilesPresentInCallableReferences() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("boundFunctionReference.kt") + public void testBoundFunctionReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundFunctionReference.kt"); + } + + @Test + @TestMetadata("boundFunctionReferenceOnInt.kt") + public void testBoundFunctionReferenceOnInt() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundFunctionReferenceOnInt.kt"); + } + + @Test + @TestMetadata("boundFunctionReferenceOnLong.kt") + public void testBoundFunctionReferenceOnLong() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundFunctionReferenceOnLong.kt"); + } + + @Test + @TestMetadata("boundInlineClassMethod.kt") + public void testBoundInlineClassMethod() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundInlineClassMethod.kt"); + } + + @Test + @TestMetadata("boundInlineClassMethodWithAny.kt") + public void testBoundInlineClassMethodWithAny() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundInlineClassMethodWithAny.kt"); + } + + @Test + @TestMetadata("boundInlineClassMethodWithInt.kt") + public void testBoundInlineClassMethodWithInt() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundInlineClassMethodWithInt.kt"); + } + + @Test + @TestMetadata("boundPropertyReference.kt") + public void testBoundPropertyReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundPropertyReference.kt"); + } + + @Test + @TestMetadata("boundPropertyReferenceOnInt.kt") + public void testBoundPropertyReferenceOnInt() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundPropertyReferenceOnInt.kt"); + } + + @Test + @TestMetadata("boundPropertyReferenceOnLong.kt") + public void testBoundPropertyReferenceOnLong() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/boundPropertyReferenceOnLong.kt"); + } + + @Test + @TestMetadata("constuctorReference.kt") + public void testConstuctorReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/constuctorReference.kt"); + } + + @Test + @TestMetadata("defaultAfterBoundReference.kt") + public void testDefaultAfterBoundReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/defaultAfterBoundReference.kt"); + } + + @Test + @TestMetadata("differentInvokeSignature.kt") + public void testDifferentInvokeSignature() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/differentInvokeSignature.kt"); + } + + @Test + @TestMetadata("differentInvokeSignature2.kt") + public void testDifferentInvokeSignature2() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/differentInvokeSignature2.kt"); + } + + @Test + @TestMetadata("differentInvokeSignature3.kt") + public void testDifferentInvokeSignature3() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/differentInvokeSignature3.kt"); + } + + @Test + @TestMetadata("functionImportedFromObject.kt") + public void testFunctionImportedFromObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/functionImportedFromObject.kt"); + } + + @Test + @TestMetadata("functionReference.kt") + public void testFunctionReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/functionReference.kt"); + } + + @Test + @TestMetadata("functionReferenceFromClass.kt") + public void testFunctionReferenceFromClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/functionReferenceFromClass.kt"); + } + + @Test + @TestMetadata("functionReferenceFromObject.kt") + public void testFunctionReferenceFromObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/functionReferenceFromObject.kt"); + } + + @Test + @TestMetadata("innerClassConstuctorReference.kt") + public void testInnerClassConstuctorReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/innerClassConstuctorReference.kt"); + } + + @Test + @TestMetadata("mutableBoundPropertyReferenceFromClass.kt") + public void testMutableBoundPropertyReferenceFromClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/mutableBoundPropertyReferenceFromClass.kt"); + } + + @Test + @TestMetadata("mutablePropertyReferenceFromClass.kt") + public void testMutablePropertyReferenceFromClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/mutablePropertyReferenceFromClass.kt"); + } + + @Test + @TestMetadata("privateFunctionReference.kt") + public void testPrivateFunctionReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/privateFunctionReference.kt"); + } + + @Test + @TestMetadata("privatePropertyReference.kt") + public void testPrivatePropertyReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/privatePropertyReference.kt"); + } + + @Test + @TestMetadata("propertyImportedFromObject.kt") + public void testPropertyImportedFromObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/propertyImportedFromObject.kt"); + } + + @Test + @TestMetadata("propertyReference.kt") + public void testPropertyReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/propertyReference.kt"); + } + + @Test + @TestMetadata("propertyReferenceFromClass.kt") + public void testPropertyReferenceFromClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/propertyReferenceFromClass.kt"); + } + + @Test + @TestMetadata("propertyReferenceFromObject.kt") + public void testPropertyReferenceFromObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/propertyReferenceFromObject.kt"); + } + + @Test + @TestMetadata("withInlineClassParameter.kt") + public void testWithInlineClassParameter() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/lambdaInlining/callableReferences/withInlineClassParameter.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/defaultValues/maskElimination") + @TestDataPath("$PROJECT_ROOT") + public class MaskElimination { + @Test + @TestMetadata("32Parameters.kt") + public void test32Parameters() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/32Parameters.kt"); + } + + @Test + @TestMetadata("33Parameters.kt") + public void test33Parameters() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/33Parameters.kt"); + } + + @Test + public void testAllFilesPresentInMaskElimination() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/defaultValues/maskElimination"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt18792.kt") + public void testKt18792() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/kt18792.kt"); + } + + @Test + @TestMetadata("kt19679.kt") + public void testKt19679() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/kt19679.kt"); + } + + @Test + @TestMetadata("kt19679_2.kt") + public void testKt19679_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/kt19679_2.kt"); + } + + @Test + @TestMetadata("kt19679_3.kt") + public void testKt19679_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/kt19679_3.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/defaultValues/maskElimination/simple.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/delegatedProperty") + @TestDataPath("$PROJECT_ROOT") + public class DelegatedProperty { + @Test + public void testAllFilesPresentInDelegatedProperty() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/delegatedProperty"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt16864.kt") + public void testKt16864() throws Exception { + runTest("compiler/testData/codegen/boxInline/delegatedProperty/kt16864.kt"); + } + + @Test + @TestMetadata("kt48498.kt") + public void testKt48498() throws Exception { + runTest("compiler/testData/codegen/boxInline/delegatedProperty/kt48498.kt"); + } + + @Test + @TestMetadata("local.kt") + public void testLocal() throws Exception { + runTest("compiler/testData/codegen/boxInline/delegatedProperty/local.kt"); + } + + @Test + @TestMetadata("localDeclaredInLambda.kt") + public void testLocalDeclaredInLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/delegatedProperty/localDeclaredInLambda.kt"); + } + + @Test + @TestMetadata("localInAnonymousObject.kt") + public void testLocalInAnonymousObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/delegatedProperty/localInAnonymousObject.kt"); + } + + @Test + @TestMetadata("localInLambda.kt") + public void testLocalInLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/delegatedProperty/localInLambda.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/enclosingInfo") + @TestDataPath("$PROJECT_ROOT") + public class EnclosingInfo { + @Test + public void testAllFilesPresentInEnclosingInfo() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enclosingInfo"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/enum") + @TestDataPath("$PROJECT_ROOT") + public class Enum { + @Test + public void testAllFilesPresentInEnum() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/enum"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt10569.kt") + public void testKt10569() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/kt10569.kt"); + } + + @Test + @TestMetadata("kt18254.kt") + public void testKt18254() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/kt18254.kt"); + } + + @Test + @TestMetadata("valueOf.kt") + public void testValueOf() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valueOf.kt"); + } + + @Test + @TestMetadata("valueOfCapturedType.kt") + public void testValueOfCapturedType() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valueOfCapturedType.kt"); + } + + @Test + @TestMetadata("valueOfChain.kt") + public void testValueOfChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valueOfChain.kt"); + } + + @Test + @TestMetadata("valueOfChainCapturedType.kt") + public void testValueOfChainCapturedType() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valueOfChainCapturedType.kt"); + } + + @Test + @TestMetadata("valueOfNonReified.kt") + public void testValueOfNonReified() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valueOfNonReified.kt"); + } + + @Test + @TestMetadata("values.kt") + public void testValues() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/values.kt"); + } + + @Test + @TestMetadata("valuesAsArray.kt") + public void testValuesAsArray() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valuesAsArray.kt"); + } + + @Test + @TestMetadata("valuesCapturedType.kt") + public void testValuesCapturedType() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valuesCapturedType.kt"); + } + + @Test + @TestMetadata("valuesChain.kt") + public void testValuesChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valuesChain.kt"); + } + + @Test + @TestMetadata("valuesChainCapturedType.kt") + public void testValuesChainCapturedType() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valuesChainCapturedType.kt"); + } + + @Test + @TestMetadata("valuesNonReified.kt") + public void testValuesNonReified() throws Exception { + runTest("compiler/testData/codegen/boxInline/enum/valuesNonReified.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/functionExpression") + @TestDataPath("$PROJECT_ROOT") + public class FunctionExpression { + @Test + public void testAllFilesPresentInFunctionExpression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/functionExpression"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("extension.kt") + public void testExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/functionExpression/extension.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/inlineArgsInplace") + @TestDataPath("$PROJECT_ROOT") + public class InlineArgsInplace { + @Test + public void testAllFilesPresentInInlineArgsInplace() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineArgsInplace"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("callArgumentReordering.kt") + public void testCallArgumentReordering() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineArgsInplace/callArgumentReordering.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/inlineClasses") + @TestDataPath("$PROJECT_ROOT") + public class InlineClasses { + @Test + public void testAllFilesPresentInInlineClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("anonymousObject.kt") + public void testAnonymousObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/anonymousObject.kt"); + } + + @Test + @TestMetadata("inlineClassWithInlineValReturningInlineClass.kt") + public void testInlineClassWithInlineValReturningInlineClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/inlineClassWithInlineValReturningInlineClass.kt"); + } + + @Test + @TestMetadata("inlineFunctionInsideInlineClassesBox.kt") + public void testInlineFunctionInsideInlineClassesBox() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/inlineFunctionInsideInlineClassesBox.kt"); + } + + @Test + @TestMetadata("noReturnTypeManglingFun.kt") + public void testNoReturnTypeManglingFun() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/noReturnTypeManglingFun.kt"); + } + + @Test + @TestMetadata("noReturnTypeManglingVal.kt") + public void testNoReturnTypeManglingVal() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/noReturnTypeManglingVal.kt"); + } + + @Test + @TestMetadata("withReturnTypeManglingFun.kt") + public void testWithReturnTypeManglingFun() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/withReturnTypeManglingFun.kt"); + } + + @Test + @TestMetadata("withReturnTypeManglingVal.kt") + public void testWithReturnTypeManglingVal() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/withReturnTypeManglingVal.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter") + @TestDataPath("$PROJECT_ROOT") + public class UnboxGenericParameter { + @Test + public void testAllFilesPresentInUnboxGenericParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface") + @TestDataPath("$PROJECT_ROOT") + public class FunInterface { + @Test + public void testAllFilesPresentInFunInterface() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("any.kt") + public void testAny() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface/any.kt"); + } + + @Test + @TestMetadata("anyN.kt") + public void testAnyN() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface/anyN.kt"); + } + + @Test + @TestMetadata("iface.kt") + public void testIface() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface/iface.kt"); + } + + @Test + @TestMetadata("ifaceChild.kt") + public void testIfaceChild() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface/ifaceChild.kt"); + } + + @Test + @TestMetadata("primitive.kt") + public void testPrimitive() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface/primitive.kt"); + } + + @Test + @TestMetadata("string.kt") + public void testString() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/funInterface/string.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda") + @TestDataPath("$PROJECT_ROOT") + public class Lambda { + @Test + public void testAllFilesPresentInLambda() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("any.kt") + public void testAny() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda/any.kt"); + } + + @Test + @TestMetadata("anyN.kt") + public void testAnyN() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda/anyN.kt"); + } + + @Test + @TestMetadata("iface.kt") + public void testIface() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda/iface.kt"); + } + + @Test + @TestMetadata("ifaceChild.kt") + public void testIfaceChild() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda/ifaceChild.kt"); + } + + @Test + @TestMetadata("primitive.kt") + public void testPrimitive() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda/primitive.kt"); + } + + @Test + @TestMetadata("string.kt") + public void testString() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/lambda/string.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral") + @TestDataPath("$PROJECT_ROOT") + public class ObjectLiteral { + @Test + public void testAllFilesPresentInObjectLiteral() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("any.kt") + public void testAny() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral/any.kt"); + } + + @Test + @TestMetadata("anyN.kt") + public void testAnyN() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral/anyN.kt"); + } + + @Test + @TestMetadata("iface.kt") + public void testIface() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral/iface.kt"); + } + + @Test + @TestMetadata("ifaceChild.kt") + public void testIfaceChild() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral/ifaceChild.kt"); + } + + @Test + @TestMetadata("primitive.kt") + public void testPrimitive() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral/primitive.kt"); + } + + @Test + @TestMetadata("string.kt") + public void testString() throws Exception { + runTest("compiler/testData/codegen/boxInline/inlineClasses/unboxGenericParameter/objectLiteral/string.kt"); + } + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/innerClasses") + @TestDataPath("$PROJECT_ROOT") + public class InnerClasses { + @Test + public void testAllFilesPresentInInnerClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/innerClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("captureThisAndOuter.kt") + public void testCaptureThisAndOuter() throws Exception { + runTest("compiler/testData/codegen/boxInline/innerClasses/captureThisAndOuter.kt"); + } + + @Test + @TestMetadata("fakeOverride.kt") + public void testFakeOverride() throws Exception { + runTest("compiler/testData/codegen/boxInline/innerClasses/fakeOverride.kt"); + } + + @Test + @TestMetadata("innerInlineFunCapturesOuter.kt") + public void testInnerInlineFunCapturesOuter() throws Exception { + runTest("compiler/testData/codegen/boxInline/innerClasses/innerInlineFunCapturesOuter.kt"); + } + + @Test + @TestMetadata("innerInlineFunCapturesOuterByAnotherInlineFun.kt") + public void testInnerInlineFunCapturesOuterByAnotherInlineFun() throws Exception { + runTest("compiler/testData/codegen/boxInline/innerClasses/innerInlineFunCapturesOuterByAnotherInlineFun.kt"); + } + + @Test + @TestMetadata("innerInlineFunCapturesOuterDeep.kt") + public void testInnerInlineFunCapturesOuterDeep() throws Exception { + runTest("compiler/testData/codegen/boxInline/innerClasses/innerInlineFunCapturesOuterDeep.kt"); + } + + @Test + @TestMetadata("innerInlineFunCapturesOuterFunRef.kt") + public void testInnerInlineFunCapturesOuterFunRef() throws Exception { + runTest("compiler/testData/codegen/boxInline/innerClasses/innerInlineFunCapturesOuterFunRef.kt"); + } + + @Test + @TestMetadata("innerInlineFunCapturesOuterWithInlineClass.kt") + public void testInnerInlineFunCapturesOuterWithInlineClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/innerClasses/innerInlineFunCapturesOuterWithInlineClass.kt"); + } + + @Test + @TestMetadata("kt12126.kt") + public void testKt12126() throws Exception { + runTest("compiler/testData/codegen/boxInline/innerClasses/kt12126.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/invokedynamic") + @TestDataPath("$PROJECT_ROOT") + public class Invokedynamic { + @Test + public void testAllFilesPresentInInvokedynamic() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/invokedynamic"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/invokedynamic/lambdas") + @TestDataPath("$PROJECT_ROOT") + public class Lambdas { + @Test + public void testAllFilesPresentInLambdas() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/invokedynamic/lambdas"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/invokedynamic/sam") + @TestDataPath("$PROJECT_ROOT") + public class Sam { + @Test + public void testAllFilesPresentInSam() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/invokedynamic/sam"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/jvmName") + @TestDataPath("$PROJECT_ROOT") + public class JvmName { + @Test + public void testAllFilesPresentInJvmName() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/jvmPackageName") + @TestDataPath("$PROJECT_ROOT") + public class JvmPackageName { + @Test + public void testAllFilesPresentInJvmPackageName() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/jvmPackageName"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/lambdaClassClash") + @TestDataPath("$PROJECT_ROOT") + public class LambdaClassClash { + @Test + public void testAllFilesPresentInLambdaClassClash() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaClassClash"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("lambdaClassClash.kt") + public void testLambdaClassClash() throws Exception { + runTest("compiler/testData/codegen/boxInline/lambdaClassClash/lambdaClassClash.kt"); + } + + @Test + @TestMetadata("noInlineLambdaX2.kt") + public void testNoInlineLambdaX2() throws Exception { + runTest("compiler/testData/codegen/boxInline/lambdaClassClash/noInlineLambdaX2.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/lambdaTransformation") + @TestDataPath("$PROJECT_ROOT") + public class LambdaTransformation { + @Test + public void testAllFilesPresentInLambdaTransformation() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/lambdaTransformation"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("lambdaCloning.kt") + public void testLambdaCloning() throws Exception { + runTest("compiler/testData/codegen/boxInline/lambdaTransformation/lambdaCloning.kt"); + } + + @Test + @TestMetadata("lambdaInLambdaNoInline.kt") + public void testLambdaInLambdaNoInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/lambdaTransformation/lambdaInLambdaNoInline.kt"); + } + + @Test + @TestMetadata("regeneratedLambdaName.kt") + public void testRegeneratedLambdaName() throws Exception { + runTest("compiler/testData/codegen/boxInline/lambdaTransformation/regeneratedLambdaName.kt"); + } + + @Test + @TestMetadata("regeneratedLambdaName2.kt") + public void testRegeneratedLambdaName2() throws Exception { + runTest("compiler/testData/codegen/boxInline/lambdaTransformation/regeneratedLambdaName2.kt"); + } + + @Test + @TestMetadata("sameCaptured.kt") + public void testSameCaptured() throws Exception { + runTest("compiler/testData/codegen/boxInline/lambdaTransformation/sameCaptured.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/localFunInLambda") + @TestDataPath("$PROJECT_ROOT") + public class LocalFunInLambda { + @Test + public void testAllFilesPresentInLocalFunInLambda() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/localFunInLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("defaultParam.kt") + public void testDefaultParam() throws Exception { + runTest("compiler/testData/codegen/boxInline/localFunInLambda/defaultParam.kt"); + } + + @Test + @TestMetadata("lambdaInLambdaCapturesAnotherFun.kt") + public void testLambdaInLambdaCapturesAnotherFun() throws Exception { + runTest("compiler/testData/codegen/boxInline/localFunInLambda/lambdaInLambdaCapturesAnotherFun.kt"); + } + + @Test + @TestMetadata("localFunInLambda.kt") + public void testLocalFunInLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/localFunInLambda/localFunInLambda.kt"); + } + + @Test + @TestMetadata("localFunInLambdaCapturesAnotherFun.kt") + public void testLocalFunInLambdaCapturesAnotherFun() throws Exception { + runTest("compiler/testData/codegen/boxInline/localFunInLambda/localFunInLambdaCapturesAnotherFun.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/multiModule") + @TestDataPath("$PROJECT_ROOT") + public class MultiModule { + @Test + public void testAllFilesPresentInMultiModule() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiModule"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("tryCatchWithRecursiveInline.kt") + public void testTryCatchWithRecursiveInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/multiModule/tryCatchWithRecursiveInline.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/multifileClasses") + @TestDataPath("$PROJECT_ROOT") + public class MultifileClasses { + @Test + public void testAllFilesPresentInMultifileClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multifileClasses"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/multiplatform") + @TestDataPath("$PROJECT_ROOT") + public class Multiplatform { + @Test + public void testAllFilesPresentInMultiplatform() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/multiplatform/defaultArguments") + @TestDataPath("$PROJECT_ROOT") + public class DefaultArguments { + @Test + public void testAllFilesPresentInDefaultArguments() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/multiplatform/defaultArguments"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("receiversAndParametersInLambda.kt") + public void testReceiversAndParametersInLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/multiplatform/defaultArguments/receiversAndParametersInLambda.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/noInline") + @TestDataPath("$PROJECT_ROOT") + public class NoInline { + @Test + public void testAllFilesPresentInNoInline() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/noInline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("extensionReceiver.kt") + public void testExtensionReceiver() throws Exception { + runTest("compiler/testData/codegen/boxInline/noInline/extensionReceiver.kt"); + } + + @Test + @TestMetadata("lambdaAsGeneric.kt") + public void testLambdaAsGeneric() throws Exception { + runTest("compiler/testData/codegen/boxInline/noInline/lambdaAsGeneric.kt"); + } + + @Test + @TestMetadata("lambdaAsNonFunction.kt") + public void testLambdaAsNonFunction() throws Exception { + runTest("compiler/testData/codegen/boxInline/noInline/lambdaAsNonFunction.kt"); + } + + @Test + @TestMetadata("noInline.kt") + public void testNoInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/noInline/noInline.kt"); + } + + @Test + @TestMetadata("noInlineLambdaChain.kt") + public void testNoInlineLambdaChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/noInline/noInlineLambdaChain.kt"); + } + + @Test + @TestMetadata("noInlineLambdaChainWithCapturedInline.kt") + public void testNoInlineLambdaChainWithCapturedInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/noInline/noInlineLambdaChainWithCapturedInline.kt"); + } + + @Test + @TestMetadata("withoutInline.kt") + public void testWithoutInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/noInline/withoutInline.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns") + @TestDataPath("$PROJECT_ROOT") + public class NonLocalReturns { + @Test + public void testAllFilesPresentInNonLocalReturns() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("explicitLocalReturn.kt") + public void testExplicitLocalReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/explicitLocalReturn.kt"); + } + + @Test + @TestMetadata("fromArrayGenerator.kt") + public void testFromArrayGenerator() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/fromArrayGenerator.kt"); + } + + @Test + @TestMetadata("fromArrayGeneratorCatch.kt") + public void testFromArrayGeneratorCatch() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/fromArrayGeneratorCatch.kt"); + } + + @Test + @TestMetadata("fromArrayGeneratorNested.kt") + public void testFromArrayGeneratorNested() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/fromArrayGeneratorNested.kt"); + } + + @Test + @TestMetadata("fromArrayGeneratorWithCapture.kt") + public void testFromArrayGeneratorWithCapture() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/fromArrayGeneratorWithCapture.kt"); + } + + @Test + @TestMetadata("fromArrayGeneratorWithCatch.kt") + public void testFromArrayGeneratorWithCatch() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/fromArrayGeneratorWithCatch.kt"); + } + + @Test + @TestMetadata("fromArrayGeneratorWithFinally.kt") + public void testFromArrayGeneratorWithFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/fromArrayGeneratorWithFinally.kt"); + } + + @Test + @TestMetadata("fromArrayGeneratorWithFinallyX2.kt") + public void testFromArrayGeneratorWithFinallyX2() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/fromArrayGeneratorWithFinallyX2.kt"); + } + + @Test + @TestMetadata("fromArrayGeneratorWithFinallyX2_2.kt") + public void testFromArrayGeneratorWithFinallyX2_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/fromArrayGeneratorWithFinallyX2_2.kt"); + } + + @Test + @TestMetadata("fromInterfaceDefaultGetter.kt") + public void testFromInterfaceDefaultGetter() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/fromInterfaceDefaultGetter.kt"); + } + + @Test + @TestMetadata("justReturnInLambda.kt") + public void testJustReturnInLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/justReturnInLambda.kt"); + } + + @Test + @TestMetadata("kt5199.kt") + public void testKt5199() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/kt5199.kt"); + } + + @Test + @TestMetadata("kt8948.kt") + public void testKt8948() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/kt8948.kt"); + } + + @Test + @TestMetadata("kt8948v2.kt") + public void testKt8948v2() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/kt8948v2.kt"); + } + + @Test + @TestMetadata("kt9304.kt") + public void testKt9304() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/kt9304.kt"); + } + + @Test + @TestMetadata("nestedNonLocals.kt") + public void testNestedNonLocals() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/nestedNonLocals.kt"); + } + + @Test + @TestMetadata("noInlineLocalReturn.kt") + public void testNoInlineLocalReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/noInlineLocalReturn.kt"); + } + + @Test + @TestMetadata("nonLocalReturnFromOuterLambda.kt") + public void testNonLocalReturnFromOuterLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/nonLocalReturnFromOuterLambda.kt"); + } + + @Test + @TestMetadata("propertyAccessors.kt") + public void testPropertyAccessors() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/propertyAccessors.kt"); + } + + @Test + @TestMetadata("returnFromFunctionExpr.kt") + public void testReturnFromFunctionExpr() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/returnFromFunctionExpr.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/simple.kt"); + } + + @Test + @TestMetadata("simpleFunctional.kt") + public void testSimpleFunctional() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/simpleFunctional.kt"); + } + + @Test + @TestMetadata("simpleVoid.kt") + public void testSimpleVoid() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/simpleVoid.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize") + @TestDataPath("$PROJECT_ROOT") + public class Deparenthesize { + @Test + public void testAllFilesPresentInDeparenthesize() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("bracket.kt") + public void testBracket() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize/bracket.kt"); + } + + @Test + @TestMetadata("labeled.kt") + public void testLabeled() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/deparenthesize/labeled.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally") + @TestDataPath("$PROJECT_ROOT") + public class TryFinally { + @Test + public void testAllFilesPresentInTryFinally() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt16417.kt") + public void testKt16417() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt16417.kt"); + } + + @Test + @TestMetadata("kt20433.kt") + public void testKt20433() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt20433.kt"); + } + + @Test + @TestMetadata("kt20433_2.kt") + public void testKt20433_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt20433_2.kt"); + } + + @Test + @TestMetadata("kt20433_2_void.kt") + public void testKt20433_2_void() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt20433_2_void.kt"); + } + + @Test + @TestMetadata("kt20433_void.kt") + public void testKt20433_void() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt20433_void.kt"); + } + + @Test + @TestMetadata("kt26384.kt") + public void testKt26384() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt26384.kt"); + } + + @Test + @TestMetadata("kt26384_2.kt") + public void testKt26384_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt26384_2.kt"); + } + + @Test + @TestMetadata("kt28546.kt") + public void testKt28546() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt28546.kt"); + } + + @Test + @TestMetadata("kt6956.kt") + public void testKt6956() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt6956.kt"); + } + + @Test + @TestMetadata("kt7273.kt") + public void testKt7273() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/kt7273.kt"); + } + + @Test + @TestMetadata("nonLocalReturnFromCatchBlock.kt") + public void testNonLocalReturnFromCatchBlock() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/nonLocalReturnFromCatchBlock.kt"); + } + + @Test + @TestMetadata("nonLocalReturnFromOuterLambda.kt") + public void testNonLocalReturnFromOuterLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/nonLocalReturnFromOuterLambda.kt"); + } + + @Test + @TestMetadata("nonLocalReturnToCatchBlock.kt") + public void testNonLocalReturnToCatchBlock() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/nonLocalReturnToCatchBlock.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite") + @TestDataPath("$PROJECT_ROOT") + public class CallSite { + @Test + public void testAllFilesPresentInCallSite() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("callSite.kt") + public void testCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite/callSite.kt"); + } + + @Test + @TestMetadata("callSiteComplex.kt") + public void testCallSiteComplex() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite/callSiteComplex.kt"); + } + + @Test + @TestMetadata("exceptionTableSplit.kt") + public void testExceptionTableSplit() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite/exceptionTableSplit.kt"); + } + + @Test + @TestMetadata("exceptionTableSplitNoReturn.kt") + public void testExceptionTableSplitNoReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite/exceptionTableSplitNoReturn.kt"); + } + + @Test + @TestMetadata("finallyInFinally.kt") + public void testFinallyInFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite/finallyInFinally.kt"); + } + + @Test + @TestMetadata("wrongVarInterval.kt") + public void testWrongVarInterval() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/callSite/wrongVarInterval.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained") + @TestDataPath("$PROJECT_ROOT") + public class Chained { + @Test + public void testAllFilesPresentInChained() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("finallyInFinally.kt") + public void testFinallyInFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/finallyInFinally.kt"); + } + + @Test + @TestMetadata("finallyInFinally2.kt") + public void testFinallyInFinally2() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/finallyInFinally2.kt"); + } + + @Test + @TestMetadata("intReturn.kt") + public void testIntReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/intReturn.kt"); + } + + @Test + @TestMetadata("intReturnComplex.kt") + public void testIntReturnComplex() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/intReturnComplex.kt"); + } + + @Test + @TestMetadata("intReturnComplex2.kt") + public void testIntReturnComplex2() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/intReturnComplex2.kt"); + } + + @Test + @TestMetadata("intReturnComplex3.kt") + public void testIntReturnComplex3() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/intReturnComplex3.kt"); + } + + @Test + @TestMetadata("intReturnComplex4.kt") + public void testIntReturnComplex4() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/intReturnComplex4.kt"); + } + + @Test + @TestMetadata("nestedLambda.kt") + public void testNestedLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/chained/nestedLambda.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite") + @TestDataPath("$PROJECT_ROOT") + public class DeclSite { + @Test + public void testAllFilesPresentInDeclSite() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("complex.kt") + public void testComplex() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/complex.kt"); + } + + @Test + @TestMetadata("intReturn.kt") + public void testIntReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/intReturn.kt"); + } + + @Test + @TestMetadata("intReturnComplex.kt") + public void testIntReturnComplex() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/intReturnComplex.kt"); + } + + @Test + @TestMetadata("longReturn.kt") + public void testLongReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/longReturn.kt"); + } + + @Test + @TestMetadata("nested.kt") + public void testNested() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/nested.kt"); + } + + @Test + @TestMetadata("returnInFinally.kt") + public void testReturnInFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/returnInFinally.kt"); + } + + @Test + @TestMetadata("returnInTry.kt") + public void testReturnInTry() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/returnInTry.kt"); + } + + @Test + @TestMetadata("returnInTryAndFinally.kt") + public void testReturnInTryAndFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/returnInTryAndFinally.kt"); + } + + @Test + @TestMetadata("severalInTry.kt") + public void testSeveralInTry() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/severalInTry.kt"); + } + + @Test + @TestMetadata("severalInTryComplex.kt") + public void testSeveralInTryComplex() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/severalInTryComplex.kt"); + } + + @Test + @TestMetadata("voidInlineFun.kt") + public void testVoidInlineFun() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/voidInlineFun.kt"); + } + + @Test + @TestMetadata("voidNonLocal.kt") + public void testVoidNonLocal() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/declSite/voidNonLocal.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable") + @TestDataPath("$PROJECT_ROOT") + public class ExceptionTable { + @Test + public void testAllFilesPresentInExceptionTable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("break.kt") + public void testBreak() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/break.kt"); + } + + @Test + @TestMetadata("continue.kt") + public void testContinue() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/continue.kt"); + } + + @Test + @TestMetadata("exceptionInFinally.kt") + public void testExceptionInFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/exceptionInFinally.kt"); + } + + @Test + @TestMetadata("forInFinally.kt") + public void testForInFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/forInFinally.kt"); + } + + @Test + @TestMetadata("innerAndExternal.kt") + public void testInnerAndExternal() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/innerAndExternal.kt"); + } + + @Test + @TestMetadata("innerAndExternalNested.kt") + public void testInnerAndExternalNested() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/innerAndExternalNested.kt"); + } + + @Test + @TestMetadata("innerAndExternalSimple.kt") + public void testInnerAndExternalSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/innerAndExternalSimple.kt"); + } + + @Test + @TestMetadata("kt31653.kt") + public void testKt31653() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/kt31653.kt"); + } + + @Test + @TestMetadata("kt31653_2.kt") + public void testKt31653_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/kt31653_2.kt"); + } + + @Test + @TestMetadata("kt31923.kt") + public void testKt31923() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/kt31923.kt"); + } + + @Test + @TestMetadata("kt31923_2.kt") + public void testKt31923_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/kt31923_2.kt"); + } + + @Test + @TestMetadata("nested.kt") + public void testNested() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/nested.kt"); + } + + @Test + @TestMetadata("nestedWithReturns.kt") + public void testNestedWithReturns() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/nestedWithReturns.kt"); + } + + @Test + @TestMetadata("nestedWithReturnsSimple.kt") + public void testNestedWithReturnsSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/nestedWithReturnsSimple.kt"); + } + + @Test + @TestMetadata("noFinally.kt") + public void testNoFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/noFinally.kt"); + } + + @Test + @TestMetadata("severalCatchClause.kt") + public void testSeveralCatchClause() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/severalCatchClause.kt"); + } + + @Test + @TestMetadata("simpleThrow.kt") + public void testSimpleThrow() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/simpleThrow.kt"); + } + + @Test + @TestMetadata("synchonized.kt") + public void testSynchonized() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/synchonized.kt"); + } + + @Test + @TestMetadata("throwInFinally.kt") + public void testThrowInFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/throwInFinally.kt"); + } + + @Test + @TestMetadata("tryCatchInFinally.kt") + public void testTryCatchInFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/exceptionTable/tryCatchInFinally.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables") + @TestDataPath("$PROJECT_ROOT") + public class Variables { + @Test + public void testAllFilesPresentInVariables() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt7792.kt") + public void testKt7792() throws Exception { + runTest("compiler/testData/codegen/boxInline/nonLocalReturns/tryFinally/variables/kt7792.kt"); + } + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/optimizations") + @TestDataPath("$PROJECT_ROOT") + public class Optimizations { + @Test + public void testAllFilesPresentInOptimizations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/optimizations"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt20844.kt") + public void testKt20844() throws Exception { + runTest("compiler/testData/codegen/boxInline/optimizations/kt20844.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/private") + @TestDataPath("$PROJECT_ROOT") + public class Private { + @Test + @TestMetadata("accessorForConst.kt") + public void testAccessorForConst() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/accessorForConst.kt"); + } + + @Test + @TestMetadata("accessorStability.kt") + public void testAccessorStability() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/accessorStability.kt"); + } + + @Test + @TestMetadata("accessorStabilityInClass.kt") + public void testAccessorStabilityInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/accessorStabilityInClass.kt"); + } + + @Test + public void testAllFilesPresentInPrivate() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/private"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("effectivePrivate.kt") + public void testEffectivePrivate() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/effectivePrivate.kt"); + } + + @Test + @TestMetadata("kt6453.kt") + public void testKt6453() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/kt6453.kt"); + } + + @Test + @TestMetadata("kt8094.kt") + public void testKt8094() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/kt8094.kt"); + } + + @Test + @TestMetadata("kt8095.kt") + public void testKt8095() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/kt8095.kt"); + } + + @Test + @TestMetadata("nestedInPrivateClass.kt") + public void testNestedInPrivateClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/nestedInPrivateClass.kt"); + } + + @Test + @TestMetadata("nestedInPrivateClass2.kt") + public void testNestedInPrivateClass2() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/nestedInPrivateClass2.kt"); + } + + @Test + @TestMetadata("privateClass.kt") + public void testPrivateClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/privateClass.kt"); + } + + @Test + @TestMetadata("privateClassExtensionLambda.kt") + public void testPrivateClassExtensionLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/privateClassExtensionLambda.kt"); + } + + @Test + @TestMetadata("privateInline.kt") + public void testPrivateInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/private/privateInline.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/property") + @TestDataPath("$PROJECT_ROOT") + public class Property { + @Test + public void testAllFilesPresentInProperty() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/property"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("augAssignmentAndInc.kt") + public void testAugAssignmentAndInc() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/augAssignmentAndInc.kt"); + } + + @Test + @TestMetadata("augAssignmentAndIncInClass.kt") + public void testAugAssignmentAndIncInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/augAssignmentAndIncInClass.kt"); + } + + @Test + @TestMetadata("augAssignmentAndIncInClassViaConvention.kt") + public void testAugAssignmentAndIncInClassViaConvention() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/augAssignmentAndIncInClassViaConvention.kt"); + } + + @Test + @TestMetadata("augAssignmentAndIncOnExtension.kt") + public void testAugAssignmentAndIncOnExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/augAssignmentAndIncOnExtension.kt"); + } + + @Test + @TestMetadata("augAssignmentAndIncOnExtensionInClass.kt") + public void testAugAssignmentAndIncOnExtensionInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/augAssignmentAndIncOnExtensionInClass.kt"); + } + + @Test + @TestMetadata("augAssignmentAndIncViaConvention.kt") + public void testAugAssignmentAndIncViaConvention() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/augAssignmentAndIncViaConvention.kt"); + } + + @Test + @TestMetadata("fromObject.kt") + public void testFromObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/fromObject.kt"); + } + + @Test + @TestMetadata("kt22649.kt") + public void testKt22649() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/kt22649.kt"); + } + + @Test + @TestMetadata("property.kt") + public void testProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/property.kt"); + } + + @Test + @TestMetadata("reifiedVal.kt") + public void testReifiedVal() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/reifiedVal.kt"); + } + + @Test + @TestMetadata("reifiedValMultiModule.kt") + public void testReifiedValMultiModule() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/reifiedValMultiModule.kt"); + } + + @Test + @TestMetadata("reifiedVar.kt") + public void testReifiedVar() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/reifiedVar.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/simple.kt"); + } + + @Test + @TestMetadata("simpleExtension.kt") + public void testSimpleExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/property/simpleExtension.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/reified") + @TestDataPath("$PROJECT_ROOT") + public class Reified { + @Test + public void testAllFilesPresentInReified() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("arrayConstructor.kt") + public void testArrayConstructor() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/arrayConstructor.kt"); + } + + @Test + @TestMetadata("arrayOf.kt") + public void testArrayOf() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/arrayOf.kt"); + } + + @Test + @TestMetadata("capturedLambda.kt") + public void testCapturedLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/capturedLambda.kt"); + } + + @Test + @TestMetadata("capturedLambda2.kt") + public void testCapturedLambda2() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/capturedLambda2.kt"); + } + + @Test + @TestMetadata("dontSubstituteNonReified.kt") + public void testDontSubstituteNonReified() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/dontSubstituteNonReified.kt"); + } + + @Test + @TestMetadata("kt18977.kt") + public void testKt18977() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt18977.kt"); + } + + @Test + @TestMetadata("kt28234.kt") + public void testKt28234() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt28234.kt"); + } + + @Test + @TestMetadata("kt35511.kt") + public void testKt35511() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt35511.kt"); + } + + @Test + @TestMetadata("kt35511_try.kt") + public void testKt35511_try() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt35511_try.kt"); + } + + @Test + @TestMetadata("kt35511_try_valueOf.kt") + public void testKt35511_try_valueOf() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt35511_try_valueOf.kt"); + } + + @Test + @TestMetadata("kt35511_try_values.kt") + public void testKt35511_try_values() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt35511_try_values.kt"); + } + + @Test + @TestMetadata("kt46584.kt") + public void testKt46584() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt46584.kt"); + } + + @Test + @TestMetadata("kt46584_2.kt") + public void testKt46584_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt46584_2.kt"); + } + + @Test + @TestMetadata("kt7017.kt") + public void testKt7017() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt7017.kt"); + } + + @Test + @TestMetadata("kt8047.kt") + public void testKt8047() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt8047.kt"); + } + + @Test + @TestMetadata("kt8047_2.kt") + public void testKt8047_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt8047_2.kt"); + } + + @Test + @TestMetadata("kt9637_2.kt") + public void testKt9637_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/kt9637_2.kt"); + } + + @Test + @TestMetadata("nameClash.kt") + public void testNameClash() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/nameClash.kt"); + } + + @Test + @TestMetadata("nonCapturingObjectInLambda.kt") + public void testNonCapturingObjectInLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/nonCapturingObjectInLambda.kt"); + } + + @Test + @TestMetadata("singletonLambda.kt") + public void testSingletonLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/singletonLambda.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/reified/checkCast") + @TestDataPath("$PROJECT_ROOT") + public class CheckCast { + @Test + public void testAllFilesPresentInCheckCast() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/checkCast"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("chain.kt") + public void testChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/chain.kt"); + } + + @Test + @TestMetadata("kt26435.kt") + public void testKt26435() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/kt26435.kt"); + } + + @Test + @TestMetadata("kt26435_2.kt") + public void testKt26435_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/kt26435_2.kt"); + } + + @Test + @TestMetadata("kt26435_3.kt") + public void testKt26435_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/kt26435_3.kt"); + } + + @Test + @TestMetadata("kt8043.kt") + public void testKt8043() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/kt8043.kt"); + } + + @Test + @TestMetadata("maxStack.kt") + public void testMaxStack() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/maxStack.kt"); + } + + @Test + @TestMetadata("nullable.kt") + public void testNullable() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/nullable.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/simple.kt"); + } + + @Test + @TestMetadata("simpleSafe.kt") + public void testSimpleSafe() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/checkCast/simpleSafe.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/reified/defaultLambda") + @TestDataPath("$PROJECT_ROOT") + public class DefaultLambda { + @Test + public void testAllFilesPresentInDefaultLambda() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/reified/isCheck") + @TestDataPath("$PROJECT_ROOT") + public class IsCheck { + @Test + public void testAllFilesPresentInIsCheck() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/reified/isCheck"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("chain.kt") + public void testChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/isCheck/chain.kt"); + } + + @Test + @TestMetadata("nullable.kt") + public void testNullable() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/isCheck/nullable.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/reified/isCheck/simple.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/signature") + @TestDataPath("$PROJECT_ROOT") + public class Signature { + @Test + public void testAllFilesPresentInSignature() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signature"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/signatureMangling") + @TestDataPath("$PROJECT_ROOT") + public class SignatureMangling { + @Test + public void testAllFilesPresentInSignatureMangling() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/signatureMangling"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/simple") + @TestDataPath("$PROJECT_ROOT") + public class Simple { + @Test + public void testAllFilesPresentInSimple() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/simple"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("captureAndArgumentIncompatibleTypes.kt") + public void testCaptureAndArgumentIncompatibleTypes() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/captureAndArgumentIncompatibleTypes.kt"); + } + + @Test + @TestMetadata("classObject.kt") + public void testClassObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/classObject.kt"); + } + + @Test + @TestMetadata("destructuring.kt") + public void testDestructuring() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/destructuring.kt"); + } + + @Test + @TestMetadata("destructuringIndexClash.kt") + public void testDestructuringIndexClash() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/destructuringIndexClash.kt"); + } + + @Test + @TestMetadata("extension.kt") + public void testExtension() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/extension.kt"); + } + + @Test + @TestMetadata("extensionLambda.kt") + public void testExtensionLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/extensionLambda.kt"); + } + + @Test + @TestMetadata("funImportedFromObject.kt") + public void testFunImportedFromObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/funImportedFromObject.kt"); + } + + @Test + @TestMetadata("inlineCallInInlineLambda.kt") + public void testInlineCallInInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/inlineCallInInlineLambda.kt"); + } + + @Test + @TestMetadata("kt17431.kt") + public void testKt17431() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/kt17431.kt"); + } + + @Test + @TestMetadata("kt28547.kt") + public void testKt28547() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/kt28547.kt"); + } + + @Test + @TestMetadata("kt28547_2.kt") + public void testKt28547_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/kt28547_2.kt"); + } + + @Test + @TestMetadata("params.kt") + public void testParams() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/params.kt"); + } + + @Test + @TestMetadata("rootConstructor.kt") + public void testRootConstructor() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/rootConstructor.kt"); + } + + @Test + @TestMetadata("safeCall.kt") + public void testSafeCall() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/safeCall.kt"); + } + + @Test + @TestMetadata("severalClosures.kt") + public void testSeveralClosures() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/severalClosures.kt"); + } + + @Test + @TestMetadata("severalUsage.kt") + public void testSeveralUsage() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/severalUsage.kt"); + } + + @Test + @TestMetadata("simpleDouble.kt") + public void testSimpleDouble() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/simpleDouble.kt"); + } + + @Test + @TestMetadata("simpleEnum.kt") + public void testSimpleEnum() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/simpleEnum.kt"); + } + + @Test + @TestMetadata("simpleGenerics.kt") + public void testSimpleGenerics() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/simpleGenerics.kt"); + } + + @Test + @TestMetadata("simpleInt.kt") + public void testSimpleInt() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/simpleInt.kt"); + } + + @Test + @TestMetadata("simpleLambda.kt") + public void testSimpleLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/simpleLambda.kt"); + } + + @Test + @TestMetadata("simpleObject.kt") + public void testSimpleObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/simpleObject.kt"); + } + + @Test + @TestMetadata("vararg.kt") + public void testVararg() throws Exception { + runTest("compiler/testData/codegen/boxInline/simple/vararg.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/smap") + @TestDataPath("$PROJECT_ROOT") + public class Smap { + @Test + public void testAllFilesPresentInSmap() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("assertion.kt") + public void testAssertion() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/assertion.kt"); + } + + @Test + @TestMetadata("classCycle.kt") + public void testClassCycle() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/classCycle.kt"); + } + + @Test + @TestMetadata("classFromDefaultPackage.kt") + public void testClassFromDefaultPackage() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/classFromDefaultPackage.kt"); + } + + @Test + @TestMetadata("coroutinesWithTailCallOtpimization.kt") + public void testCoroutinesWithTailCallOtpimization() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/coroutinesWithTailCallOtpimization.kt"); + } + + @Test + @TestMetadata("crossroutines.kt") + public void testCrossroutines() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/crossroutines.kt"); + } + + @Test + @TestMetadata("defaultFunction.kt") + public void testDefaultFunction() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultFunction.kt"); + } + + @Test + @TestMetadata("defaultFunctionWithInlineCall.kt") + public void testDefaultFunctionWithInlineCall() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultFunctionWithInlineCall.kt"); + } + + @Test + @TestMetadata("forInline.kt") + public void testForInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/forInline.kt"); + } + + @Test + @TestMetadata("inlineProperty.kt") + public void testInlineProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/inlineProperty.kt"); + } + + @Test + @TestMetadata("interleavedFiles.kt") + public void testInterleavedFiles() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/interleavedFiles.kt"); + } + + @Test + @TestMetadata("kt23369.kt") + public void testKt23369() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/kt23369.kt"); + } + + @Test + @TestMetadata("kt23369_2.kt") + public void testKt23369_2() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/kt23369_2.kt"); + } + + @Test + @TestMetadata("kt23369_3.kt") + public void testKt23369_3() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/kt23369_3.kt"); + } + + @Test + @TestMetadata("kt35006.kt") + public void testKt35006() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/kt35006.kt"); + } + + @Test + @TestMetadata("oneFile.kt") + public void testOneFile() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/oneFile.kt"); + } + + @Test + @TestMetadata("rangeFolding.kt") + public void testRangeFolding() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/rangeFolding.kt"); + } + + @Test + @TestMetadata("rangeFoldingInClass.kt") + public void testRangeFoldingInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/rangeFoldingInClass.kt"); + } + + @Test + @TestMetadata("smap.kt") + public void testSmap() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/smap.kt"); + } + + @Test + @TestMetadata("smapWithNewSyntax.kt") + public void testSmapWithNewSyntax() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/smapWithNewSyntax.kt"); + } + + @Test + @TestMetadata("smapWithOldSyntax.kt") + public void testSmapWithOldSyntax() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/smapWithOldSyntax.kt"); + } + + @Test + @TestMetadata("tryFinally1.kt") + public void testTryFinally1() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/tryFinally1.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/smap/anonymous") + @TestDataPath("$PROJECT_ROOT") + public class Anonymous { + @Test + public void testAllFilesPresentInAnonymous() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/anonymous"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt19175.kt") + public void testKt19175() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/kt19175.kt"); + } + + @Test + @TestMetadata("lambda.kt") + public void testLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/lambda.kt"); + } + + @Test + @TestMetadata("lambdaOnCallSite.kt") + public void testLambdaOnCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/lambdaOnCallSite.kt"); + } + + @Test + @TestMetadata("lambdaOnInlineCallSite.kt") + public void testLambdaOnInlineCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/lambdaOnInlineCallSite.kt"); + } + + @Test + @TestMetadata("object.kt") + public void testObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/object.kt"); + } + + @Test + @TestMetadata("objectOnCallSite.kt") + public void testObjectOnCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/objectOnCallSite.kt"); + } + + @Test + @TestMetadata("objectOnInlineCallSite.kt") + public void testObjectOnInlineCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/objectOnInlineCallSite.kt"); + } + + @Test + @TestMetadata("objectOnInlineCallSite2.kt") + public void testObjectOnInlineCallSite2() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/objectOnInlineCallSite2.kt"); + } + + @Test + @TestMetadata("objectOnInlineCallSiteWithCapture.kt") + public void testObjectOnInlineCallSiteWithCapture() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/objectOnInlineCallSiteWithCapture.kt"); + } + + @Test + @TestMetadata("severalMappingsForDefaultFile.kt") + public void testSeveralMappingsForDefaultFile() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/anonymous/severalMappingsForDefaultFile.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/smap/defaultLambda") + @TestDataPath("$PROJECT_ROOT") + public class DefaultLambda { + @Test + public void testAllFilesPresentInDefaultLambda() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/defaultLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("defaultLambdaInAnonymous.kt") + public void testDefaultLambdaInAnonymous() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/defaultLambdaInAnonymous.kt"); + } + + @Test + @TestMetadata("inlineAnonymousInDefault.kt") + public void testInlineAnonymousInDefault() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/inlineAnonymousInDefault.kt"); + } + + @Test + @TestMetadata("inlineAnonymousInDefault2.kt") + public void testInlineAnonymousInDefault2() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/inlineAnonymousInDefault2.kt"); + } + + @Test + @TestMetadata("inlineInDefault.kt") + public void testInlineInDefault() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/inlineInDefault.kt"); + } + + @Test + @TestMetadata("inlineInDefault2.kt") + public void testInlineInDefault2() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/inlineInDefault2.kt"); + } + + @Test + @TestMetadata("kt21827.kt") + public void testKt21827() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/kt21827.kt"); + } + + @Test + @TestMetadata("nested.kt") + public void testNested() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/nested.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/simple.kt"); + } + + @Test + @TestMetadata("simple2.kt") + public void testSimple2() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/defaultLambda/simple2.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/smap/inlineOnly") + @TestDataPath("$PROJECT_ROOT") + public class InlineOnly { + @Test + public void testAllFilesPresentInInlineOnly() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/inlineOnly"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("noSmap.kt") + public void testNoSmap() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/inlineOnly/noSmap.kt"); + } + + @Test + @TestMetadata("noSmapWithProperty.kt") + public void testNoSmapWithProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/inlineOnly/noSmapWithProperty.kt"); + } + + @Test + @TestMetadata("stdlibInlineOnly.kt") + public void testStdlibInlineOnly() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/inlineOnly/stdlibInlineOnly.kt"); + } + + @Test + @TestMetadata("stdlibInlineOnlyOneLine.kt") + public void testStdlibInlineOnlyOneLine() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/inlineOnly/stdlibInlineOnlyOneLine.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/smap/newsmap") + @TestDataPath("$PROJECT_ROOT") + public class Newsmap { + @Test + public void testAllFilesPresentInNewsmap() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/newsmap"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("differentMapping.kt") + public void testDifferentMapping() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/newsmap/differentMapping.kt"); + } + + @Test + @TestMetadata("mappingInInlineFunLambda.kt") + public void testMappingInInlineFunLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/newsmap/mappingInInlineFunLambda.kt"); + } + + @Test + @TestMetadata("mappingInSubInlineLambda.kt") + public void testMappingInSubInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/newsmap/mappingInSubInlineLambda.kt"); + } + + @Test + @TestMetadata("mappingInSubInlineLambdaSameFileInline.kt") + public void testMappingInSubInlineLambdaSameFileInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/newsmap/mappingInSubInlineLambdaSameFileInline.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/smap/resolve") + @TestDataPath("$PROJECT_ROOT") + public class Resolve { + @Test + public void testAllFilesPresentInResolve() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/smap/resolve"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("inlineComponent.kt") + public void testInlineComponent() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/resolve/inlineComponent.kt"); + } + + @Test + @TestMetadata("inlineIterator.kt") + public void testInlineIterator() throws Exception { + runTest("compiler/testData/codegen/boxInline/smap/resolve/inlineIterator.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/special") + @TestDataPath("$PROJECT_ROOT") + public class Special { + @Test + public void testAllFilesPresentInSpecial() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/special"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("identityCheck.kt") + public void testIdentityCheck() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/identityCheck.kt"); + } + + @Test + @TestMetadata("ifBranches.kt") + public void testIfBranches() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/ifBranches.kt"); + } + + @Test + @TestMetadata("iinc.kt") + public void testIinc() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/iinc.kt"); + } + + @Test + @TestMetadata("inlineChain.kt") + public void testInlineChain() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/inlineChain.kt"); + } + + @Test + @TestMetadata("loopInStoreLoadChains.kt") + public void testLoopInStoreLoadChains() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/loopInStoreLoadChains.kt"); + } + + @Test + @TestMetadata("loopInStoreLoadChains2.kt") + public void testLoopInStoreLoadChains2() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/loopInStoreLoadChains2.kt"); + } + + @Test + @TestMetadata("plusAssign.kt") + public void testPlusAssign() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/plusAssign.kt"); + } + + @Test + @TestMetadata("stackHeightBug.kt") + public void testStackHeightBug() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/stackHeightBug.kt"); + } + + @Test + @TestMetadata("unusedInlineLambda.kt") + public void testUnusedInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/special/unusedInlineLambda.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/stackOnReturn") + @TestDataPath("$PROJECT_ROOT") + public class StackOnReturn { + @Test + public void testAllFilesPresentInStackOnReturn() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/stackOnReturn"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("elvis.kt") + public void testElvis() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/elvis.kt"); + } + + @Test + @TestMetadata("ifThenElse.kt") + public void testIfThenElse() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/ifThenElse.kt"); + } + + @Test + @TestMetadata("kt11499.kt") + public void testKt11499() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/kt11499.kt"); + } + + @Test + @TestMetadata("kt17591.kt") + public void testKt17591() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/kt17591.kt"); + } + + @Test + @TestMetadata("kt17591a.kt") + public void testKt17591a() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/kt17591a.kt"); + } + + @Test + @TestMetadata("kt17591b.kt") + public void testKt17591b() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/kt17591b.kt"); + } + + @Test + @TestMetadata("mixedTypesOnStack1.kt") + public void testMixedTypesOnStack1() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/mixedTypesOnStack1.kt"); + } + + @Test + @TestMetadata("mixedTypesOnStack2.kt") + public void testMixedTypesOnStack2() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/mixedTypesOnStack2.kt"); + } + + @Test + @TestMetadata("mixedTypesOnStack3.kt") + public void testMixedTypesOnStack3() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/mixedTypesOnStack3.kt"); + } + + @Test + @TestMetadata("nonLocalReturn1.kt") + public void testNonLocalReturn1() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/nonLocalReturn1.kt"); + } + + @Test + @TestMetadata("nonLocalReturn2.kt") + public void testNonLocalReturn2() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/nonLocalReturn2.kt"); + } + + @Test + @TestMetadata("nonLocalReturn3.kt") + public void testNonLocalReturn3() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/nonLocalReturn3.kt"); + } + + @Test + @TestMetadata("poppedLocalReturn.kt") + public void testPoppedLocalReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/poppedLocalReturn.kt"); + } + + @Test + @TestMetadata("poppedLocalReturn2.kt") + public void testPoppedLocalReturn2() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/poppedLocalReturn2.kt"); + } + + @Test + @TestMetadata("returnLong.kt") + public void testReturnLong() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/returnLong.kt"); + } + + @Test + @TestMetadata("tryFinally.kt") + public void testTryFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/stackOnReturn/tryFinally.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/suspend") + @TestDataPath("$PROJECT_ROOT") + public class Suspend { + @Test + public void testAllFilesPresentInSuspend() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("capturedVariables.kt") + public void testCapturedVariables() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/capturedVariables.kt"); + } + + @Test + @TestMetadata("crossinlineSuspendLambdaInsideCrossinlineSuspendLambda.kt") + public void testCrossinlineSuspendLambdaInsideCrossinlineSuspendLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/crossinlineSuspendLambdaInsideCrossinlineSuspendLambda.kt"); + } + + @Test + @TestMetadata("delegatedProperties.kt") + public void testDelegatedProperties() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/delegatedProperties.kt"); + } + + @Test + @TestMetadata("doubleRegenerationWithNonSuspendingLambda.kt") + public void testDoubleRegenerationWithNonSuspendingLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/doubleRegenerationWithNonSuspendingLambda.kt"); + } + + @Test + @TestMetadata("inlineOrdinaryOfCrossinlineSuspend.kt") + public void testInlineOrdinaryOfCrossinlineSuspend() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/inlineOrdinaryOfCrossinlineSuspend.kt"); + } + + @Test + @TestMetadata("inlineOrdinaryOfNoinlineSuspend.kt") + public void testInlineOrdinaryOfNoinlineSuspend() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/inlineOrdinaryOfNoinlineSuspend.kt"); + } + + @Test + @TestMetadata("inlinePassthrough.kt") + public void testInlinePassthrough() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/inlinePassthrough.kt"); + } + + @Test + @TestMetadata("inlineSuspendOfCrossinlineOrdinary.kt") + public void testInlineSuspendOfCrossinlineOrdinary() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/inlineSuspendOfCrossinlineOrdinary.kt"); + } + + @Test + @TestMetadata("inlineSuspendOfCrossinlineSuspend.kt") + public void testInlineSuspendOfCrossinlineSuspend() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/inlineSuspendOfCrossinlineSuspend.kt"); + } + + @Test + @TestMetadata("inlineSuspendOfNoinlineOrdinary.kt") + public void testInlineSuspendOfNoinlineOrdinary() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/inlineSuspendOfNoinlineOrdinary.kt"); + } + + @Test + @TestMetadata("inlineSuspendOfNoinlineSuspend.kt") + public void testInlineSuspendOfNoinlineSuspend() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/inlineSuspendOfNoinlineSuspend.kt"); + } + + @Test + @TestMetadata("inlineSuspendOfOrdinary.kt") + public void testInlineSuspendOfOrdinary() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/inlineSuspendOfOrdinary.kt"); + } + + @Test + @TestMetadata("inlineSuspendOfSuspend.kt") + public void testInlineSuspendOfSuspend() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/inlineSuspendOfSuspend.kt"); + } + + @Test + @TestMetadata("kt26658.kt") + public void testKt26658() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/kt26658.kt"); + } + + @Test + @TestMetadata("maxStackWithCrossinline.kt") + public void testMaxStackWithCrossinline() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/maxStackWithCrossinline.kt"); + } + + @Test + @TestMetadata("multipleLocals.kt") + public void testMultipleLocals() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/multipleLocals.kt"); + } + + @Test + @TestMetadata("multipleSuspensionPoints.kt") + public void testMultipleSuspensionPoints() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/multipleSuspensionPoints.kt"); + } + + @Test + @TestMetadata("nonLocalReturn.kt") + public void testNonLocalReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/nonLocalReturn.kt"); + } + + @Test + @TestMetadata("nonSuspendCrossinline.kt") + public void testNonSuspendCrossinline() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/nonSuspendCrossinline.kt"); + } + + @Test + @TestMetadata("returnValue.kt") + public void testReturnValue() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/returnValue.kt"); + } + + @Test + @TestMetadata("tryCatchReceiver.kt") + public void testTryCatchReceiver() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/tryCatchReceiver.kt"); + } + + @Test + @TestMetadata("tryCatchStackTransform.kt") + public void testTryCatchStackTransform() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/tryCatchStackTransform.kt"); + } + + @Test + @TestMetadata("twiceRegeneratedAnonymousObject.kt") + public void testTwiceRegeneratedAnonymousObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/twiceRegeneratedAnonymousObject.kt"); + } + + @Test + @TestMetadata("twiceRegeneratedSuspendLambda.kt") + public void testTwiceRegeneratedSuspendLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/twiceRegeneratedSuspendLambda.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/suspend/callableReference") + @TestDataPath("$PROJECT_ROOT") + public class CallableReference { + @Test + public void testAllFilesPresentInCallableReference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/callableReference"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("isAsReified.kt") + public void testIsAsReified() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/callableReference/isAsReified.kt"); + } + + @Test + @TestMetadata("isAsReified2.kt") + public void testIsAsReified2() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/callableReference/isAsReified2.kt"); + } + + @Test + @TestMetadata("nonTailCall.kt") + public void testNonTailCall() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/callableReference/nonTailCall.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/callableReference/simple.kt"); + } + + @Test + @TestMetadata("unitReturn.kt") + public void testUnitReturn() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/callableReference/unitReturn.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/suspend/defaultParameter") + @TestDataPath("$PROJECT_ROOT") + public class DefaultParameter { + @Test + public void testAllFilesPresentInDefaultParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/defaultParameter"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("defaultInlineLambda.kt") + public void testDefaultInlineLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/defaultParameter/defaultInlineLambda.kt"); + } + + @Test + @TestMetadata("defaultInlineReference.kt") + public void testDefaultInlineReference() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/defaultParameter/defaultInlineReference.kt"); + } + + @Test + @TestMetadata("defaultValueCrossinline.kt") + public void testDefaultValueCrossinline() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/defaultParameter/defaultValueCrossinline.kt"); + } + + @Test + @TestMetadata("defaultValueInClass.kt") + public void testDefaultValueInClass() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/defaultParameter/defaultValueInClass.kt"); + } + + @Test + @TestMetadata("defaultValueInline.kt") + public void testDefaultValueInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/defaultParameter/defaultValueInline.kt"); + } + + @Test + @TestMetadata("defaultValueInlineFromMultiFileFacade.kt") + public void testDefaultValueInlineFromMultiFileFacade() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/defaultParameter/defaultValueInlineFromMultiFileFacade.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/suspend/inlineClass") + @TestDataPath("$PROJECT_ROOT") + public class InlineClass { + @Test + public void testAllFilesPresentInInlineClass() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineClass"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("returnBoxedFromLambda.kt") + public void testReturnBoxedFromLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/inlineClass/returnBoxedFromLambda.kt"); + } + + @Test + @TestMetadata("returnUnboxedDirect.kt") + public void testReturnUnboxedDirect() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/inlineClass/returnUnboxedDirect.kt"); + } + + @Test + @TestMetadata("returnUnboxedFromLambda.kt") + public void testReturnUnboxedFromLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/inlineClass/returnUnboxedFromLambda.kt"); + } + + @Test + @TestMetadata("returnUnboxedResume.kt") + public void testReturnUnboxedResume() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/inlineClass/returnUnboxedResume.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline") + @TestDataPath("$PROJECT_ROOT") + public class InlineUsedAsNoinline { + @Test + public void testAllFilesPresentInInlineUsedAsNoinline() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("inlineOnly.kt") + public void testInlineOnly() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline/inlineOnly.kt"); + } + + @Test + @TestMetadata("simpleNamed.kt") + public void testSimpleNamed() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline/simpleNamed.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/suspend/receiver") + @TestDataPath("$PROJECT_ROOT") + public class Receiver { + @Test + public void testAllFilesPresentInReceiver() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/receiver"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("inlineOrdinaryOfCrossinlineSuspend.kt") + public void testInlineOrdinaryOfCrossinlineSuspend() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/receiver/inlineOrdinaryOfCrossinlineSuspend.kt"); + } + + @Test + @TestMetadata("inlineOrdinaryOfNoinlineSuspend.kt") + public void testInlineOrdinaryOfNoinlineSuspend() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/receiver/inlineOrdinaryOfNoinlineSuspend.kt"); + } + + @Test + @TestMetadata("inlineSuspendOfCrossinlineOrdinary.kt") + public void testInlineSuspendOfCrossinlineOrdinary() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfCrossinlineOrdinary.kt"); + } + + @Test + @TestMetadata("inlineSuspendOfCrossinlineSuspend.kt") + public void testInlineSuspendOfCrossinlineSuspend() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfCrossinlineSuspend.kt"); + } + + @Test + @TestMetadata("inlineSuspendOfNoinlineOrdinary.kt") + public void testInlineSuspendOfNoinlineOrdinary() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfNoinlineOrdinary.kt"); + } + + @Test + @TestMetadata("inlineSuspendOfNoinlineSuspend.kt") + public void testInlineSuspendOfNoinlineSuspend() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfNoinlineSuspend.kt"); + } + + @Test + @TestMetadata("inlineSuspendOfOrdinary.kt") + public void testInlineSuspendOfOrdinary() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfOrdinary.kt"); + } + + @Test + @TestMetadata("inlineSuspendOfSuspend.kt") + public void testInlineSuspendOfSuspend() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/receiver/inlineSuspendOfSuspend.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/suspend/stateMachine") + @TestDataPath("$PROJECT_ROOT") + public class StateMachine { + @Test + public void testAllFilesPresentInStateMachine() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/suspend/stateMachine"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("crossingCoroutineBoundaries.kt") + public void testCrossingCoroutineBoundaries() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/crossingCoroutineBoundaries.kt"); + } + + @Test + @TestMetadata("independentInline.kt") + public void testIndependentInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/independentInline.kt"); + } + + @Test + @TestMetadata("innerLambda.kt") + public void testInnerLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/innerLambda.kt"); + } + + @Test + @TestMetadata("innerLambdaInsideLambda.kt") + public void testInnerLambdaInsideLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/innerLambdaInsideLambda.kt"); + } + + @Test + @TestMetadata("innerLambdaWithoutCrossinline.kt") + public void testInnerLambdaWithoutCrossinline() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/innerLambdaWithoutCrossinline.kt"); + } + + @Test + @TestMetadata("innerMadness.kt") + public void testInnerMadness() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/innerMadness.kt"); + } + + @Test + @TestMetadata("innerMadnessCallSite.kt") + public void testInnerMadnessCallSite() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/innerMadnessCallSite.kt"); + } + + @Test + @TestMetadata("innerObject.kt") + public void testInnerObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/innerObject.kt"); + } + + @Test + @TestMetadata("innerObjectInsideInnerObject.kt") + public void testInnerObjectInsideInnerObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/innerObjectInsideInnerObject.kt"); + } + + @Test + @TestMetadata("innerObjectRetransformation.kt") + public void testInnerObjectRetransformation() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/innerObjectRetransformation.kt"); + } + + @Test + @TestMetadata("innerObjectSeveralFunctions.kt") + public void testInnerObjectSeveralFunctions() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/innerObjectSeveralFunctions.kt"); + } + + @Test + @TestMetadata("innerObjectWithoutCapturingCrossinline.kt") + public void testInnerObjectWithoutCapturingCrossinline() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/innerObjectWithoutCapturingCrossinline.kt"); + } + + @Test + @TestMetadata("insideObject.kt") + public void testInsideObject() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/insideObject.kt"); + } + + @Test + @TestMetadata("kt30708.kt") + public void testKt30708() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/kt30708.kt"); + } + + @Test + @TestMetadata("lambdaTransformation.kt") + public void testLambdaTransformation() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/lambdaTransformation.kt"); + } + + @Test + @TestMetadata("normalInline.kt") + public void testNormalInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/normalInline.kt"); + } + + @Test + @TestMetadata("numberOfSuspentions.kt") + public void testNumberOfSuspentions() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/numberOfSuspentions.kt"); + } + + @Test + @TestMetadata("objectInsideLambdas.kt") + public void testObjectInsideLambdas() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/objectInsideLambdas.kt"); + } + + @Test + @TestMetadata("oneInlineTwoCaptures.kt") + public void testOneInlineTwoCaptures() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/oneInlineTwoCaptures.kt"); + } + + @Test + @TestMetadata("passLambda.kt") + public void testPassLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/passLambda.kt"); + } + + @Test + @TestMetadata("passParameter.kt") + public void testPassParameter() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/passParameter.kt"); + } + + @Test + @TestMetadata("passParameterLambda.kt") + public void testPassParameterLambda() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/passParameterLambda.kt"); + } + + @Test + @TestMetadata("unreachableSuspendMarker.kt") + public void testUnreachableSuspendMarker() throws Exception { + runTest("compiler/testData/codegen/boxInline/suspend/stateMachine/unreachableSuspendMarker.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/syntheticAccessors") + @TestDataPath("$PROJECT_ROOT") + public class SyntheticAccessors { + @Test + public void testAllFilesPresentInSyntheticAccessors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("constField.kt") + public void testConstField() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/constField.kt"); + } + + @Test + @TestMetadata("packagePrivateMembers.kt") + public void testPackagePrivateMembers() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/packagePrivateMembers.kt"); + } + + @Test + @TestMetadata("propertyModifiers.kt") + public void testPropertyModifiers() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/propertyModifiers.kt"); + } + + @Test + @TestMetadata("protectedMembers.kt") + public void testProtectedMembers() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/protectedMembers.kt"); + } + + @Test + @TestMetadata("protectedMembersFromSuper.kt") + public void testProtectedMembersFromSuper() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/protectedMembersFromSuper.kt"); + } + + @Test + @TestMetadata("superCall.kt") + public void testSuperCall() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/superCall.kt"); + } + + @Test + @TestMetadata("superCallFromMultipleSubclasses.kt") + public void testSuperCallFromMultipleSubclasses() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/superCallFromMultipleSubclasses.kt"); + } + + @Test + @TestMetadata("superProperty.kt") + public void testSuperProperty() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/superProperty.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda") + @TestDataPath("$PROJECT_ROOT") + public class WithinInlineLambda { + @Test + public void testAllFilesPresentInWithinInlineLambda() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("directFieldAccess.kt") + public void testDirectFieldAccess() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/directFieldAccess.kt"); + } + + @Test + @TestMetadata("directFieldAccessInCrossInline.kt") + public void testDirectFieldAccessInCrossInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/directFieldAccessInCrossInline.kt"); + } + + @Test + @TestMetadata("privateCall.kt") + public void testPrivateCall() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/privateCall.kt"); + } + + @Test + @TestMetadata("privateInCrossInline.kt") + public void testPrivateInCrossInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/privateInCrossInline.kt"); + } + + @Test + @TestMetadata("privateInDefaultStubArgument.kt") + public void testPrivateInDefaultStubArgument() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/privateInDefaultStubArgument.kt"); + } + + @Test + @TestMetadata("protectedInCrossinline.kt") + public void testProtectedInCrossinline() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/protectedInCrossinline.kt"); + } + + @Test + @TestMetadata("protectedMembersFromSuper.kt") + public void testProtectedMembersFromSuper() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/protectedMembersFromSuper.kt"); + } + + @Test + @TestMetadata("superCall.kt") + public void testSuperCall() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/superCall.kt"); + } + + @Test + @TestMetadata("superInCrossInline.kt") + public void testSuperInCrossInline() throws Exception { + runTest("compiler/testData/codegen/boxInline/syntheticAccessors/withinInlineLambda/superInCrossInline.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/trait") + @TestDataPath("$PROJECT_ROOT") + public class Trait { + @Test + public void testAllFilesPresentInTrait() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/trait"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("trait.kt") + public void testTrait() throws Exception { + runTest("compiler/testData/codegen/boxInline/trait/trait.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/tryCatchFinally") + @TestDataPath("$PROJECT_ROOT") + public class TryCatchFinally { + @Test + public void testAllFilesPresentInTryCatchFinally() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/tryCatchFinally"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt5863.kt") + public void testKt5863() throws Exception { + runTest("compiler/testData/codegen/boxInline/tryCatchFinally/kt5863.kt"); + } + + @Test + @TestMetadata("tryCatch.kt") + public void testTryCatch() throws Exception { + runTest("compiler/testData/codegen/boxInline/tryCatchFinally/tryCatch.kt"); + } + + @Test + @TestMetadata("tryCatch2.kt") + public void testTryCatch2() throws Exception { + runTest("compiler/testData/codegen/boxInline/tryCatchFinally/tryCatch2.kt"); + } + + @Test + @TestMetadata("tryCatchFinally.kt") + public void testTryCatchFinally() throws Exception { + runTest("compiler/testData/codegen/boxInline/tryCatchFinally/tryCatchFinally.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/boxInline/varargs") + @TestDataPath("$PROJECT_ROOT") + public class Varargs { + @Test + public void testAllFilesPresentInVarargs() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxInline/varargs"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt17653.kt") + public void testKt17653() throws Exception { + runTest("compiler/testData/codegen/boxInline/varargs/kt17653.kt"); + } + + @Test + @TestMetadata("varargAndDefaultParameters.kt") + public void testVarargAndDefaultParameters() throws Exception { + runTest("compiler/testData/codegen/boxInline/varargs/varargAndDefaultParameters.kt"); + } + + @Test + @TestMetadata("varargAndDefaultParameters2.kt") + public void testVarargAndDefaultParameters2() throws Exception { + runTest("compiler/testData/codegen/boxInline/varargs/varargAndDefaultParameters2.kt"); + } + } +} diff --git a/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/K1WasmCodegenBoxTestGenerated.java b/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/K1WasmCodegenBoxTestGenerated.java new file mode 100644 index 00000000000..d796bdeaab3 --- /dev/null +++ b/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/K1WasmCodegenBoxTestGenerated.java @@ -0,0 +1,37016 @@ +/* + * Copyright 2010-2023 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.wasm.test; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.TargetBackend; +import org.jetbrains.kotlin.test.utils.TransformersFunctions; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.GenerateWasmTestsKt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("compiler/testData/codegen/box") +@TestDataPath("$PROJECT_ROOT") +public class K1WasmCodegenBoxTestGenerated extends AbstractK1WasmCodegenBoxTest { + @Test + public void testAllFilesPresentInBox() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true, "compileKotlinAgainstKotlin"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/annotations") + @TestDataPath("$PROJECT_ROOT") + public class Annotations { + @Test + public void testAllFilesPresentInAnnotations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("genericAnnotations.kt") + public void testGenericAnnotations() throws Exception { + runTest("compiler/testData/codegen/box/annotations/genericAnnotations.kt"); + } + + @Test + @TestMetadata("nestedAnnotation.kt") + public void testNestedAnnotation() throws Exception { + runTest("compiler/testData/codegen/box/annotations/nestedAnnotation.kt"); + } + + @Test + @TestMetadata("nestedClassesInAnnotations.kt") + public void testNestedClassesInAnnotations() throws Exception { + runTest("compiler/testData/codegen/box/annotations/nestedClassesInAnnotations.kt"); + } + + @Test + @TestMetadata("resolveWithLowPriorityAnnotation.kt") + public void testResolveWithLowPriorityAnnotation() throws Exception { + runTest("compiler/testData/codegen/box/annotations/resolveWithLowPriorityAnnotation.kt"); + } + + @Test + @TestMetadata("selfReferentialAnnotation.kt") + public void testSelfReferentialAnnotation() throws Exception { + runTest("compiler/testData/codegen/box/annotations/selfReferentialAnnotation.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/annotations/annotatedLambda") + @TestDataPath("$PROJECT_ROOT") + public class AnnotatedLambda { + @Test + public void testAllFilesPresentInAnnotatedLambda() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/annotatedLambda"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/annotations/instances") + @TestDataPath("$PROJECT_ROOT") + public class Instances { + @Test + public void testAllFilesPresentInInstances() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/instances"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("annotationEqHc.kt") + public void testAnnotationEqHc() throws Exception { + runTest("compiler/testData/codegen/box/annotations/instances/annotationEqHc.kt"); + } + + @Test + @TestMetadata("annotationFromStdlib.kt") + public void testAnnotationFromStdlib() throws Exception { + runTest("compiler/testData/codegen/box/annotations/instances/annotationFromStdlib.kt"); + } + + @Test + @TestMetadata("annotationInstances.kt") + public void testAnnotationInstances() throws Exception { + runTest("compiler/testData/codegen/box/annotations/instances/annotationInstances.kt"); + } + + @Test + @TestMetadata("annotationInstancesEmptyDefault.kt") + public void testAnnotationInstancesEmptyDefault() throws Exception { + runTest("compiler/testData/codegen/box/annotations/instances/annotationInstancesEmptyDefault.kt"); + } + + @Test + @TestMetadata("annotationInstancesEmptyDefaultLowered.kt") + public void testAnnotationInstancesEmptyDefaultLowered() throws Exception { + runTest("compiler/testData/codegen/box/annotations/instances/annotationInstancesEmptyDefaultLowered.kt"); + } + + @Test + @TestMetadata("annotationToString.kt") + public void testAnnotationToString() throws Exception { + runTest("compiler/testData/codegen/box/annotations/instances/annotationToString.kt"); + } + + @Test + @TestMetadata("annotationsUnsignedTypes.kt") + public void testAnnotationsUnsignedTypes() throws Exception { + runTest("compiler/testData/codegen/box/annotations/instances/annotationsUnsignedTypes.kt"); + } + + @Test + @TestMetadata("inInlineFunction.kt") + public void testInInlineFunction() throws Exception { + runTest("compiler/testData/codegen/box/annotations/instances/inInlineFunction.kt"); + } + + @Test + @TestMetadata("multifileEqHc.kt") + public void testMultifileEqHc() throws Exception { + runTest("compiler/testData/codegen/box/annotations/instances/multifileEqHc.kt"); + } + + @Test + @TestMetadata("multiplatformInstantiation.kt") + public void testMultiplatformInstantiation() throws Exception { + runTest("compiler/testData/codegen/box/annotations/instances/multiplatformInstantiation.kt"); + } + + @Test + @TestMetadata("nestedAnnotationInstances.kt") + public void testNestedAnnotationInstances() throws Exception { + runTest("compiler/testData/codegen/box/annotations/instances/nestedAnnotationInstances.kt"); + } + + @Test + @TestMetadata("varargInAnnotationParameterInstantiation.kt") + public void testVarargInAnnotationParameterInstantiation() throws Exception { + runTest("compiler/testData/codegen/box/annotations/instances/varargInAnnotationParameterInstantiation.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/annotations/kClassMapping") + @TestDataPath("$PROJECT_ROOT") + public class KClassMapping { + @Test + public void testAllFilesPresentInKClassMapping() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/kClassMapping"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/annotations/repeatable") + @TestDataPath("$PROJECT_ROOT") + public class Repeatable { + @Test + public void testAllFilesPresentInRepeatable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/repeatable"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/annotations/typeAnnotations") + @TestDataPath("$PROJECT_ROOT") + public class TypeAnnotations { + @Test + public void testAllFilesPresentInTypeAnnotations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/annotations/typeAnnotations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("checkingNotincorporatedInputTypes.kt") + public void testCheckingNotincorporatedInputTypes() throws Exception { + runTest("compiler/testData/codegen/box/annotations/typeAnnotations/checkingNotincorporatedInputTypes.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/argumentOrder") + @TestDataPath("$PROJECT_ROOT") + public class ArgumentOrder { + @Test + public void testAllFilesPresentInArgumentOrder() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/argumentOrder"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("argumentOrderInObjectSuperCall.kt") + public void testArgumentOrderInObjectSuperCall() throws Exception { + runTest("compiler/testData/codegen/box/argumentOrder/argumentOrderInObjectSuperCall.kt"); + } + + @Test + @TestMetadata("argumentOrderInSuperCall.kt") + public void testArgumentOrderInSuperCall() throws Exception { + runTest("compiler/testData/codegen/box/argumentOrder/argumentOrderInSuperCall.kt"); + } + + @Test + @TestMetadata("arguments.kt") + public void testArguments() throws Exception { + runTest("compiler/testData/codegen/box/argumentOrder/arguments.kt"); + } + + @Test + @TestMetadata("captured.kt") + public void testCaptured() throws Exception { + runTest("compiler/testData/codegen/box/argumentOrder/captured.kt"); + } + + @Test + @TestMetadata("capturedInExtension.kt") + public void testCapturedInExtension() throws Exception { + runTest("compiler/testData/codegen/box/argumentOrder/capturedInExtension.kt"); + } + + @Test + @TestMetadata("defaults.kt") + public void testDefaults() throws Exception { + runTest("compiler/testData/codegen/box/argumentOrder/defaults.kt"); + } + + @Test + @TestMetadata("extension.kt") + public void testExtension() throws Exception { + runTest("compiler/testData/codegen/box/argumentOrder/extension.kt"); + } + + @Test + @TestMetadata("extensionInClass.kt") + public void testExtensionInClass() throws Exception { + runTest("compiler/testData/codegen/box/argumentOrder/extensionInClass.kt"); + } + + @Test + @TestMetadata("kt17691WithEnabledFeature.kt") + public void testKt17691WithEnabledFeature() throws Exception { + runTest("compiler/testData/codegen/box/argumentOrder/kt17691WithEnabledFeature.kt"); + } + + @Test + @TestMetadata("kt9277.kt") + public void testKt9277() throws Exception { + runTest("compiler/testData/codegen/box/argumentOrder/kt9277.kt"); + } + + @Test + @TestMetadata("lambdaMigration.kt") + public void testLambdaMigration() throws Exception { + runTest("compiler/testData/codegen/box/argumentOrder/lambdaMigration.kt"); + } + + @Test + @TestMetadata("lambdaMigrationInClass.kt") + public void testLambdaMigrationInClass() throws Exception { + runTest("compiler/testData/codegen/box/argumentOrder/lambdaMigrationInClass.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/argumentOrder/simple.kt"); + } + + @Test + @TestMetadata("simpleInClass.kt") + public void testSimpleInClass() throws Exception { + runTest("compiler/testData/codegen/box/argumentOrder/simpleInClass.kt"); + } + + @Test + @TestMetadata("singleSideEffect.kt") + public void testSingleSideEffect() throws Exception { + runTest("compiler/testData/codegen/box/argumentOrder/singleSideEffect.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/arrays") + @TestDataPath("$PROJECT_ROOT") + public class Arrays { + @Test + public void testAllFilesPresentInArrays() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("arrayConstructorWithNonInlineLambda.kt") + public void testArrayConstructorWithNonInlineLambda() throws Exception { + runTest("compiler/testData/codegen/box/arrays/arrayConstructorWithNonInlineLambda.kt"); + } + + @Test + @TestMetadata("arrayConstructorsSimple.kt") + public void testArrayConstructorsSimple() throws Exception { + runTest("compiler/testData/codegen/box/arrays/arrayConstructorsSimple.kt"); + } + + @Test + @TestMetadata("arrayGetAssignMultiIndex.kt") + public void testArrayGetAssignMultiIndex() throws Exception { + runTest("compiler/testData/codegen/box/arrays/arrayGetAssignMultiIndex.kt"); + } + + @Test + @TestMetadata("arrayGetMultiIndex.kt") + public void testArrayGetMultiIndex() throws Exception { + runTest("compiler/testData/codegen/box/arrays/arrayGetMultiIndex.kt"); + } + + @Test + @TestMetadata("arrayInstanceOf.kt") + public void testArrayInstanceOf() throws Exception { + runTest("compiler/testData/codegen/box/arrays/arrayInstanceOf.kt"); + } + + @Test + @TestMetadata("arrayPlusAssign.kt") + public void testArrayPlusAssign() throws Exception { + runTest("compiler/testData/codegen/box/arrays/arrayPlusAssign.kt"); + } + + @Test + @TestMetadata("collectionAssignGetMultiIndex.kt") + public void testCollectionAssignGetMultiIndex() throws Exception { + runTest("compiler/testData/codegen/box/arrays/collectionAssignGetMultiIndex.kt"); + } + + @Test + @TestMetadata("collectionGetMultiIndex.kt") + public void testCollectionGetMultiIndex() throws Exception { + runTest("compiler/testData/codegen/box/arrays/collectionGetMultiIndex.kt"); + } + + @Test + @TestMetadata("constantArrayOfAny.kt") + public void testConstantArrayOfAny() throws Exception { + runTest("compiler/testData/codegen/box/arrays/constantArrayOfAny.kt"); + } + + @Test + @TestMetadata("forEachBooleanArray.kt") + public void testForEachBooleanArray() throws Exception { + runTest("compiler/testData/codegen/box/arrays/forEachBooleanArray.kt"); + } + + @Test + @TestMetadata("forEachByteArray.kt") + public void testForEachByteArray() throws Exception { + runTest("compiler/testData/codegen/box/arrays/forEachByteArray.kt"); + } + + @Test + @TestMetadata("forEachCharArray.kt") + public void testForEachCharArray() throws Exception { + runTest("compiler/testData/codegen/box/arrays/forEachCharArray.kt"); + } + + @Test + @TestMetadata("forEachDoubleArray.kt") + public void testForEachDoubleArray() throws Exception { + runTest("compiler/testData/codegen/box/arrays/forEachDoubleArray.kt"); + } + + @Test + @TestMetadata("forEachFloatArray.kt") + public void testForEachFloatArray() throws Exception { + runTest("compiler/testData/codegen/box/arrays/forEachFloatArray.kt"); + } + + @Test + @TestMetadata("forEachIntArray.kt") + public void testForEachIntArray() throws Exception { + runTest("compiler/testData/codegen/box/arrays/forEachIntArray.kt"); + } + + @Test + @TestMetadata("forEachLongArray.kt") + public void testForEachLongArray() throws Exception { + runTest("compiler/testData/codegen/box/arrays/forEachLongArray.kt"); + } + + @Test + @TestMetadata("forEachShortArray.kt") + public void testForEachShortArray() throws Exception { + runTest("compiler/testData/codegen/box/arrays/forEachShortArray.kt"); + } + + @Test + @TestMetadata("genericArrayInObjectLiteralConstructor.kt") + public void testGenericArrayInObjectLiteralConstructor() throws Exception { + runTest("compiler/testData/codegen/box/arrays/genericArrayInObjectLiteralConstructor.kt"); + } + + @Test + @TestMetadata("hashMap.kt") + public void testHashMap() throws Exception { + runTest("compiler/testData/codegen/box/arrays/hashMap.kt"); + } + + @Test + @TestMetadata("inProjectionAsParameter.kt") + public void testInProjectionAsParameter() throws Exception { + runTest("compiler/testData/codegen/box/arrays/inProjectionAsParameter.kt"); + } + + @Test + @TestMetadata("inProjectionOfArray.kt") + public void testInProjectionOfArray() throws Exception { + runTest("compiler/testData/codegen/box/arrays/inProjectionOfArray.kt"); + } + + @Test + @TestMetadata("inProjectionOfList.kt") + public void testInProjectionOfList() throws Exception { + runTest("compiler/testData/codegen/box/arrays/inProjectionOfList.kt"); + } + + @Test + @TestMetadata("indices.kt") + public void testIndices() throws Exception { + runTest("compiler/testData/codegen/box/arrays/indices.kt"); + } + + @Test + @TestMetadata("indicesChar.kt") + public void testIndicesChar() throws Exception { + runTest("compiler/testData/codegen/box/arrays/indicesChar.kt"); + } + + @Test + @TestMetadata("inlineInitializer.kt") + public void testInlineInitializer() throws Exception { + runTest("compiler/testData/codegen/box/arrays/inlineInitializer.kt"); + } + + @Test + @TestMetadata("iterator.kt") + public void testIterator() throws Exception { + runTest("compiler/testData/codegen/box/arrays/iterator.kt"); + } + + @Test + @TestMetadata("iteratorBooleanArray.kt") + public void testIteratorBooleanArray() throws Exception { + runTest("compiler/testData/codegen/box/arrays/iteratorBooleanArray.kt"); + } + + @Test + @TestMetadata("iteratorByteArray.kt") + public void testIteratorByteArray() throws Exception { + runTest("compiler/testData/codegen/box/arrays/iteratorByteArray.kt"); + } + + @Test + @TestMetadata("iteratorByteArrayNextByte.kt") + public void testIteratorByteArrayNextByte() throws Exception { + runTest("compiler/testData/codegen/box/arrays/iteratorByteArrayNextByte.kt"); + } + + @Test + @TestMetadata("iteratorCharArray.kt") + public void testIteratorCharArray() throws Exception { + runTest("compiler/testData/codegen/box/arrays/iteratorCharArray.kt"); + } + + @Test + @TestMetadata("iteratorDoubleArray.kt") + public void testIteratorDoubleArray() throws Exception { + runTest("compiler/testData/codegen/box/arrays/iteratorDoubleArray.kt"); + } + + @Test + @TestMetadata("iteratorFloatArray.kt") + public void testIteratorFloatArray() throws Exception { + runTest("compiler/testData/codegen/box/arrays/iteratorFloatArray.kt"); + } + + @Test + @TestMetadata("iteratorIntArray.kt") + public void testIteratorIntArray() throws Exception { + runTest("compiler/testData/codegen/box/arrays/iteratorIntArray.kt"); + } + + @Test + @TestMetadata("iteratorLongArray.kt") + public void testIteratorLongArray() throws Exception { + runTest("compiler/testData/codegen/box/arrays/iteratorLongArray.kt"); + } + + @Test + @TestMetadata("iteratorLongArrayNextLong.kt") + public void testIteratorLongArrayNextLong() throws Exception { + runTest("compiler/testData/codegen/box/arrays/iteratorLongArrayNextLong.kt"); + } + + @Test + @TestMetadata("iteratorShortArray.kt") + public void testIteratorShortArray() throws Exception { + runTest("compiler/testData/codegen/box/arrays/iteratorShortArray.kt"); + } + + @Test + @TestMetadata("kt1291.kt") + public void testKt1291() throws Exception { + runTest("compiler/testData/codegen/box/arrays/kt1291.kt"); + } + + @Test + @TestMetadata("kt238.kt") + public void testKt238() throws Exception { + runTest("compiler/testData/codegen/box/arrays/kt238.kt"); + } + + @Test + @TestMetadata("kt2997.kt") + public void testKt2997() throws Exception { + runTest("compiler/testData/codegen/box/arrays/kt2997.kt"); + } + + @Test + @TestMetadata("kt33.kt") + public void testKt33() throws Exception { + runTest("compiler/testData/codegen/box/arrays/kt33.kt"); + } + + @Test + @TestMetadata("kt34291_16dimensions.kt") + public void testKt34291_16dimensions() throws Exception { + runTest("compiler/testData/codegen/box/arrays/kt34291_16dimensions.kt"); + } + + @Test + @TestMetadata("kt3771.kt") + public void testKt3771() throws Exception { + runTest("compiler/testData/codegen/box/arrays/kt3771.kt"); + } + + @Test + @TestMetadata("kt4118.kt") + public void testKt4118() throws Exception { + runTest("compiler/testData/codegen/box/arrays/kt4118.kt"); + } + + @Test + @TestMetadata("kt42932.kt") + public void testKt42932() throws Exception { + runTest("compiler/testData/codegen/box/arrays/kt42932.kt"); + } + + @Test + @TestMetadata("kt4348.kt") + public void testKt4348() throws Exception { + runTest("compiler/testData/codegen/box/arrays/kt4348.kt"); + } + + @Test + @TestMetadata("kt4357.kt") + public void testKt4357() throws Exception { + runTest("compiler/testData/codegen/box/arrays/kt4357.kt"); + } + + @Test + @TestMetadata("kt47483.kt") + public void testKt47483() throws Exception { + runTest("compiler/testData/codegen/box/arrays/kt47483.kt"); + } + + @Test + @TestMetadata("kt503.kt") + public void testKt503() throws Exception { + runTest("compiler/testData/codegen/box/arrays/kt503.kt"); + } + + @Test + @TestMetadata("kt55984.kt") + public void testKt55984() throws Exception { + runTest("compiler/testData/codegen/box/arrays/kt55984.kt"); + } + + @Test + @TestMetadata("kt594.kt") + public void testKt594() throws Exception { + runTest("compiler/testData/codegen/box/arrays/kt594.kt"); + } + + @Test + @TestMetadata("kt7009.kt") + public void testKt7009() throws Exception { + runTest("compiler/testData/codegen/box/arrays/kt7009.kt"); + } + + @Test + @TestMetadata("kt7288.kt") + public void testKt7288() throws Exception { + runTest("compiler/testData/codegen/box/arrays/kt7288.kt"); + } + + @Test + @TestMetadata("kt779.kt") + public void testKt779() throws Exception { + runTest("compiler/testData/codegen/box/arrays/kt779.kt"); + } + + @Test + @TestMetadata("kt945.kt") + public void testKt945() throws Exception { + runTest("compiler/testData/codegen/box/arrays/kt945.kt"); + } + + @Test + @TestMetadata("kt950.kt") + public void testKt950() throws Exception { + runTest("compiler/testData/codegen/box/arrays/kt950.kt"); + } + + @Test + @TestMetadata("longAsIndex.kt") + public void testLongAsIndex() throws Exception { + runTest("compiler/testData/codegen/box/arrays/longAsIndex.kt"); + } + + @Test + @TestMetadata("multiArrayConstructors.kt") + public void testMultiArrayConstructors() throws Exception { + runTest("compiler/testData/codegen/box/arrays/multiArrayConstructors.kt"); + } + + @Test + @TestMetadata("nonLocalReturnArrayConstructor.kt") + public void testNonLocalReturnArrayConstructor() throws Exception { + runTest("compiler/testData/codegen/box/arrays/nonLocalReturnArrayConstructor.kt"); + } + + @Test + @TestMetadata("nonNullArray.kt") + public void testNonNullArray() throws Exception { + runTest("compiler/testData/codegen/box/arrays/nonNullArray.kt"); + } + + @Test + @TestMetadata("primitiveArrays.kt") + public void testPrimitiveArrays() throws Exception { + runTest("compiler/testData/codegen/box/arrays/primitiveArrays.kt"); + } + + @Test + @TestMetadata("stdlib.kt") + public void testStdlib() throws Exception { + runTest("compiler/testData/codegen/box/arrays/stdlib.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/arrays/arraysOfInlineClass") + @TestDataPath("$PROJECT_ROOT") + public class ArraysOfInlineClass { + @Test + @TestMetadata("accessArrayOfInlineClass.kt") + public void testAccessArrayOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/arrays/arraysOfInlineClass/accessArrayOfInlineClass.kt"); + } + + @Test + @TestMetadata("accessArrayOfUnsigned.kt") + public void testAccessArrayOfUnsigned() throws Exception { + runTest("compiler/testData/codegen/box/arrays/arraysOfInlineClass/accessArrayOfUnsigned.kt"); + } + + @Test + public void testAllFilesPresentInArraysOfInlineClass() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/arraysOfInlineClass"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("arrayOfInlineClassOfArrayOfInlineClass.kt") + public void testArrayOfInlineClassOfArrayOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/arrays/arraysOfInlineClass/arrayOfInlineClassOfArrayOfInlineClass.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/arrays/forInReversed") + @TestDataPath("$PROJECT_ROOT") + public class ForInReversed { + @Test + public void testAllFilesPresentInForInReversed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/forInReversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("reversedArrayOriginalUpdatedInLoopBody.kt") + public void testReversedArrayOriginalUpdatedInLoopBody() throws Exception { + runTest("compiler/testData/codegen/box/arrays/forInReversed/reversedArrayOriginalUpdatedInLoopBody.kt"); + } + + @Test + @TestMetadata("reversedArrayReversedArrayOriginalUpdatedInLoopBody.kt") + public void testReversedArrayReversedArrayOriginalUpdatedInLoopBody() throws Exception { + runTest("compiler/testData/codegen/box/arrays/forInReversed/reversedArrayReversedArrayOriginalUpdatedInLoopBody.kt"); + } + + @Test + @TestMetadata("reversedOriginalUpdatedInLoopBody.kt") + public void testReversedOriginalUpdatedInLoopBody() throws Exception { + runTest("compiler/testData/codegen/box/arrays/forInReversed/reversedOriginalUpdatedInLoopBody.kt"); + } + + @Test + @TestMetadata("reversedReversedOriginalUpdatedInLoopBody.kt") + public void testReversedReversedOriginalUpdatedInLoopBody() throws Exception { + runTest("compiler/testData/codegen/box/arrays/forInReversed/reversedReversedOriginalUpdatedInLoopBody.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/arrays/forInUnsignedArray") + @TestDataPath("$PROJECT_ROOT") + public class ForInUnsignedArray { + @Test + public void testAllFilesPresentInForInUnsignedArray() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/forInUnsignedArray"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("forInUnsignedArray.kt") + public void testForInUnsignedArray() throws Exception { + runTest("compiler/testData/codegen/box/arrays/forInUnsignedArray/forInUnsignedArray.kt"); + } + + @Test + @TestMetadata("forInUnsignedArrayIndices.kt") + public void testForInUnsignedArrayIndices() throws Exception { + runTest("compiler/testData/codegen/box/arrays/forInUnsignedArray/forInUnsignedArrayIndices.kt"); + } + + @Test + @TestMetadata("forInUnsignedArrayIndicesReversed.kt") + public void testForInUnsignedArrayIndicesReversed() throws Exception { + runTest("compiler/testData/codegen/box/arrays/forInUnsignedArray/forInUnsignedArrayIndicesReversed.kt"); + } + + @Test + @TestMetadata("forInUnsignedArrayReversed.kt") + public void testForInUnsignedArrayReversed() throws Exception { + runTest("compiler/testData/codegen/box/arrays/forInUnsignedArray/forInUnsignedArrayReversed.kt"); + } + + @Test + @TestMetadata("forInUnsignedArrayWithIndex.kt") + public void testForInUnsignedArrayWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/arrays/forInUnsignedArray/forInUnsignedArrayWithIndex.kt"); + } + + @Test + @TestMetadata("forInUnsignedArrayWithIndexNoElementVar.kt") + public void testForInUnsignedArrayWithIndexNoElementVar() throws Exception { + runTest("compiler/testData/codegen/box/arrays/forInUnsignedArray/forInUnsignedArrayWithIndexNoElementVar.kt"); + } + + @Test + @TestMetadata("forInUnsignedArrayWithIndexNoIndexVar.kt") + public void testForInUnsignedArrayWithIndexNoIndexVar() throws Exception { + runTest("compiler/testData/codegen/box/arrays/forInUnsignedArray/forInUnsignedArrayWithIndexNoIndexVar.kt"); + } + + @Test + @TestMetadata("forInUnsignedArrayWithIndexReversed.kt") + public void testForInUnsignedArrayWithIndexReversed() throws Exception { + runTest("compiler/testData/codegen/box/arrays/forInUnsignedArray/forInUnsignedArrayWithIndexReversed.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/arrays/multiDecl") + @TestDataPath("$PROJECT_ROOT") + public class MultiDecl { + @Test + public void testAllFilesPresentInMultiDecl() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt15560.kt") + public void testKt15560() throws Exception { + runTest("compiler/testData/codegen/box/arrays/multiDecl/kt15560.kt"); + } + + @Test + @TestMetadata("kt15568.kt") + public void testKt15568() throws Exception { + runTest("compiler/testData/codegen/box/arrays/multiDecl/kt15568.kt"); + } + + @Test + @TestMetadata("kt15575.kt") + public void testKt15575() throws Exception { + runTest("compiler/testData/codegen/box/arrays/multiDecl/kt15575.kt"); + } + + @Test + @TestMetadata("MultiDeclFor.kt") + public void testMultiDeclFor() throws Exception { + runTest("compiler/testData/codegen/box/arrays/multiDecl/MultiDeclFor.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentExtensions.kt") + public void testMultiDeclForComponentExtensions() throws Exception { + runTest("compiler/testData/codegen/box/arrays/multiDecl/MultiDeclForComponentExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensions.kt") + public void testMultiDeclForComponentMemberExtensions() throws Exception { + runTest("compiler/testData/codegen/box/arrays/multiDecl/MultiDeclForComponentMemberExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") + public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { + runTest("compiler/testData/codegen/box/arrays/multiDecl/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); + } + + @Test + @TestMetadata("MultiDeclForValCaptured.kt") + public void testMultiDeclForValCaptured() throws Exception { + runTest("compiler/testData/codegen/box/arrays/multiDecl/MultiDeclForValCaptured.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/arrays/multiDecl/int") + @TestDataPath("$PROJECT_ROOT") + public class Int { + @Test + public void testAllFilesPresentInInt() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/int"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("MultiDeclForComponentExtensions.kt") + public void testMultiDeclForComponentExtensions() throws Exception { + runTest("compiler/testData/codegen/box/arrays/multiDecl/int/MultiDeclForComponentExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentExtensionsValCaptured.kt") + public void testMultiDeclForComponentExtensionsValCaptured() throws Exception { + runTest("compiler/testData/codegen/box/arrays/multiDecl/int/MultiDeclForComponentExtensionsValCaptured.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensions.kt") + public void testMultiDeclForComponentMemberExtensions() throws Exception { + runTest("compiler/testData/codegen/box/arrays/multiDecl/int/MultiDeclForComponentMemberExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") + public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { + runTest("compiler/testData/codegen/box/arrays/multiDecl/int/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/arrays/multiDecl/long") + @TestDataPath("$PROJECT_ROOT") + public class Long { + @Test + public void testAllFilesPresentInLong() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/arrays/multiDecl/long"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("MultiDeclForComponentExtensions.kt") + public void testMultiDeclForComponentExtensions() throws Exception { + runTest("compiler/testData/codegen/box/arrays/multiDecl/long/MultiDeclForComponentExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentExtensionsValCaptured.kt") + public void testMultiDeclForComponentExtensionsValCaptured() throws Exception { + runTest("compiler/testData/codegen/box/arrays/multiDecl/long/MultiDeclForComponentExtensionsValCaptured.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensions.kt") + public void testMultiDeclForComponentMemberExtensions() throws Exception { + runTest("compiler/testData/codegen/box/arrays/multiDecl/long/MultiDeclForComponentMemberExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") + public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { + runTest("compiler/testData/codegen/box/arrays/multiDecl/long/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); + } + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/assert") + @TestDataPath("$PROJECT_ROOT") + public class Assert { + @Test + public void testAllFilesPresentInAssert() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("alwaysDisable.kt") + public void testAlwaysDisable() throws Exception { + runTest("compiler/testData/codegen/box/assert/alwaysDisable.kt"); + } + + @Test + @TestMetadata("alwaysEnable.kt") + public void testAlwaysEnable() throws Exception { + runTest("compiler/testData/codegen/box/assert/alwaysEnable.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/assert/jvm") + @TestDataPath("$PROJECT_ROOT") + public class Jvm { + @Test + public void testAllFilesPresentInJvm() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/assert/jvm"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/binaryOp") + @TestDataPath("$PROJECT_ROOT") + public class BinaryOp { + @Test + public void testAllFilesPresentInBinaryOp() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/binaryOp"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("bitwiseOp.kt") + public void testBitwiseOp() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/bitwiseOp.kt"); + } + + @Test + @TestMetadata("bitwiseOpAny.kt") + public void testBitwiseOpAny() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/bitwiseOpAny.kt"); + } + + @Test + @TestMetadata("bitwiseOpNullable.kt") + public void testBitwiseOpNullable() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/bitwiseOpNullable.kt"); + } + + @Test + @TestMetadata("call.kt") + public void testCall() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/call.kt"); + } + + @Test + @TestMetadata("callAny.kt") + public void testCallAny() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/callAny.kt"); + } + + @Test + @TestMetadata("callNullable.kt") + public void testCallNullable() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/callNullable.kt"); + } + + @Test + @TestMetadata("compareBoxedChars.kt") + public void testCompareBoxedChars() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/compareBoxedChars.kt"); + } + + @Test + @TestMetadata("divisionByZero.kt") + public void testDivisionByZero() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/divisionByZero.kt"); + } + + @Test + @TestMetadata("eqNullableDoubles.kt") + public void testEqNullableDoubles() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/eqNullableDoubles.kt"); + } + + @Test + @TestMetadata("eqNullableDoublesToInt.kt") + public void testEqNullableDoublesToInt() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/eqNullableDoublesToInt.kt"); + } + + @Test + @TestMetadata("eqNullableDoublesToIntWithTP.kt") + public void testEqNullableDoublesToIntWithTP() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/eqNullableDoublesToIntWithTP.kt"); + } + + @Test + @TestMetadata("eqNullableDoublesWithTP.kt") + public void testEqNullableDoublesWithTP() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/eqNullableDoublesWithTP.kt"); + } + + @Test + @TestMetadata("eqNullableShortToShort.kt") + public void testEqNullableShortToShort() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/eqNullableShortToShort.kt"); + } + + @Test + @TestMetadata("eqNullableToPrimitiveWithSideEffects.kt") + public void testEqNullableToPrimitiveWithSideEffects() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/eqNullableToPrimitiveWithSideEffects.kt"); + } + + @Test + @TestMetadata("intrinsic.kt") + public void testIntrinsic() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/intrinsic.kt"); + } + + @Test + @TestMetadata("intrinsicAny.kt") + public void testIntrinsicAny() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/intrinsicAny.kt"); + } + + @Test + @TestMetadata("intrinsicNullable.kt") + public void testIntrinsicNullable() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/intrinsicNullable.kt"); + } + + @Test + @TestMetadata("kt11163.kt") + public void testKt11163() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/kt11163.kt"); + } + + @Test + @TestMetadata("kt11163_properIeee754comparisons.kt") + public void testKt11163_properIeee754comparisons() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/kt11163_properIeee754comparisons.kt"); + } + + @Test + @TestMetadata("kt23030_properIeee754comparisons.kt") + public void testKt23030_properIeee754comparisons() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/kt23030_properIeee754comparisons.kt"); + } + + @Test + @TestMetadata("kt44402.kt") + public void testKt44402() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/kt44402.kt"); + } + + @Test + @TestMetadata("kt6747_identityEquals.kt") + public void testKt6747_identityEquals() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/kt6747_identityEquals.kt"); + } + + @Test + @TestMetadata("overflowChar.kt") + public void testOverflowChar() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/overflowChar.kt"); + } + + @Test + @TestMetadata("overflowInt.kt") + public void testOverflowInt() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/overflowInt.kt"); + } + + @Test + @TestMetadata("overflowLong.kt") + public void testOverflowLong() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/overflowLong.kt"); + } + + @Test + @TestMetadata("primitiveEqualsSafeCall.kt") + public void testPrimitiveEqualsSafeCall() throws Exception { + runTest("compiler/testData/codegen/box/binaryOp/primitiveEqualsSafeCall.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/boxingOptimization") + @TestDataPath("$PROJECT_ROOT") + public class BoxingOptimization { + @Test + public void testAllFilesPresentInBoxingOptimization() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/boxingOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("boxedIntegersCmp.kt") + public void testBoxedIntegersCmp() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/boxedIntegersCmp.kt"); + } + + @Test + @TestMetadata("boxedPrimitivesAreEqual.kt") + public void testBoxedPrimitivesAreEqual() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/boxedPrimitivesAreEqual.kt"); + } + + @Test + @TestMetadata("boxedRealsCmp.kt") + public void testBoxedRealsCmp() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/boxedRealsCmp.kt"); + } + + @Test + @TestMetadata("casts.kt") + public void testCasts() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/casts.kt"); + } + + @Test + @TestMetadata("checkcastAndInstanceOf2.kt") + public void testCheckcastAndInstanceOf2() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/checkcastAndInstanceOf2.kt"); + } + + @Test + @TestMetadata("explicitEqualsOnDouble.kt") + public void testExplicitEqualsOnDouble() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/explicitEqualsOnDouble.kt"); + } + + @Test + @TestMetadata("fold.kt") + public void testFold() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/fold.kt"); + } + + @Test + @TestMetadata("foldRange.kt") + public void testFoldRange() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/foldRange.kt"); + } + + @Test + @TestMetadata("intCompareTo.kt") + public void testIntCompareTo() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/intCompareTo.kt"); + } + + @Test + @TestMetadata("kt15871.kt") + public void testKt15871() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/kt15871.kt"); + } + + @Test + @TestMetadata("kt19767.kt") + public void testKt19767() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/kt19767.kt"); + } + + @Test + @TestMetadata("kt19767_2.kt") + public void testKt19767_2() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/kt19767_2.kt"); + } + + @Test + @TestMetadata("kt19767_chain.kt") + public void testKt19767_chain() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/kt19767_chain.kt"); + } + + @Test + @TestMetadata("kt46859.kt") + public void testKt46859() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/kt46859.kt"); + } + + @Test + @TestMetadata("kt48394.kt") + public void testKt48394() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/kt48394.kt"); + } + + @Test + @TestMetadata("kt49092a.kt") + public void testKt49092a() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/kt49092a.kt"); + } + + @Test + @TestMetadata("kt49092b.kt") + public void testKt49092b() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/kt49092b.kt"); + } + + @Test + @TestMetadata("kt49092c.kt") + public void testKt49092c() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/kt49092c.kt"); + } + + @Test + @TestMetadata("kt49092d.kt") + public void testKt49092d() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/kt49092d.kt"); + } + + @Test + @TestMetadata("kt49092e.kt") + public void testKt49092e() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/kt49092e.kt"); + } + + @Test + @TestMetadata("kt49092f.kt") + public void testKt49092f() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/kt49092f.kt"); + } + + @Test + @TestMetadata("kt49548.kt") + public void testKt49548() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/kt49548.kt"); + } + + @Test + @TestMetadata("kt49548a.kt") + public void testKt49548a() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/kt49548a.kt"); + } + + @Test + @TestMetadata("kt5493.kt") + public void testKt5493() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/kt5493.kt"); + } + + @Test + @TestMetadata("kt5588.kt") + public void testKt5588() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/kt5588.kt"); + } + + @Test + @TestMetadata("kt5844.kt") + public void testKt5844() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/kt5844.kt"); + } + + @Test + @TestMetadata("kt6842.kt") + public void testKt6842() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/kt6842.kt"); + } + + @Test + @TestMetadata("maxMinByOrNull.kt") + public void testMaxMinByOrNull() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/maxMinByOrNull.kt"); + } + + @Test + @TestMetadata("nullCheck.kt") + public void testNullCheck() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/nullCheck.kt"); + } + + @Test + @TestMetadata("progressions.kt") + public void testProgressions() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/progressions.kt"); + } + + @Test + @TestMetadata("safeCallWithElvis.kt") + public void testSafeCallWithElvis() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/safeCallWithElvis.kt"); + } + + @Test + @TestMetadata("safeCallWithElvisMultipleFiles.kt") + public void testSafeCallWithElvisMultipleFiles() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/safeCallWithElvisMultipleFiles.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/simple.kt"); + } + + @Test + @TestMetadata("simpleUninitializedMerge.kt") + public void testSimpleUninitializedMerge() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/simpleUninitializedMerge.kt"); + } + + @Test + @TestMetadata("taintedValues.kt") + public void testTaintedValues() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/taintedValues.kt"); + } + + @Test + @TestMetadata("taintedValuesBox.kt") + public void testTaintedValuesBox() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/taintedValuesBox.kt"); + } + + @Test + @TestMetadata("unsafeRemoving.kt") + public void testUnsafeRemoving() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/unsafeRemoving.kt"); + } + + @Test + @TestMetadata("unsignedArrayForEach.kt") + public void testUnsignedArrayForEach() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/unsignedArrayForEach.kt"); + } + + @Test + @TestMetadata("variables.kt") + public void testVariables() throws Exception { + runTest("compiler/testData/codegen/box/boxingOptimization/variables.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/bridges") + @TestDataPath("$PROJECT_ROOT") + public class Bridges { + @Test + @TestMetadata("abstractOverrideBridge.kt") + public void testAbstractOverrideBridge() throws Exception { + runTest("compiler/testData/codegen/box/bridges/abstractOverrideBridge.kt"); + } + + @Test + public void testAllFilesPresentInBridges() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("complexMultiInheritance.kt") + public void testComplexMultiInheritance() throws Exception { + runTest("compiler/testData/codegen/box/bridges/complexMultiInheritance.kt"); + } + + @Test + @TestMetadata("complexTraitImpl.kt") + public void testComplexTraitImpl() throws Exception { + runTest("compiler/testData/codegen/box/bridges/complexTraitImpl.kt"); + } + + @Test + @TestMetadata("covariantGenericDiamond.kt") + public void testCovariantGenericDiamond() throws Exception { + runTest("compiler/testData/codegen/box/bridges/covariantGenericDiamond.kt"); + } + + @Test + @TestMetadata("delegation.kt") + public void testDelegation() throws Exception { + runTest("compiler/testData/codegen/box/bridges/delegation.kt"); + } + + @Test + @TestMetadata("delegationComplex.kt") + public void testDelegationComplex() throws Exception { + runTest("compiler/testData/codegen/box/bridges/delegationComplex.kt"); + } + + @Test + @TestMetadata("delegationComplexWithList.kt") + public void testDelegationComplexWithList() throws Exception { + runTest("compiler/testData/codegen/box/bridges/delegationComplexWithList.kt"); + } + + @Test + @TestMetadata("delegationProperty.kt") + public void testDelegationProperty() throws Exception { + runTest("compiler/testData/codegen/box/bridges/delegationProperty.kt"); + } + + @Test + @TestMetadata("diamond.kt") + public void testDiamond() throws Exception { + runTest("compiler/testData/codegen/box/bridges/diamond.kt"); + } + + @Test + @TestMetadata("fakeCovariantOverride.kt") + public void testFakeCovariantOverride() throws Exception { + runTest("compiler/testData/codegen/box/bridges/fakeCovariantOverride.kt"); + } + + @Test + @TestMetadata("fakeGenericCovariantOverride.kt") + public void testFakeGenericCovariantOverride() throws Exception { + runTest("compiler/testData/codegen/box/bridges/fakeGenericCovariantOverride.kt"); + } + + @Test + @TestMetadata("fakeGenericCovariantOverrideWithDelegation.kt") + public void testFakeGenericCovariantOverrideWithDelegation() throws Exception { + runTest("compiler/testData/codegen/box/bridges/fakeGenericCovariantOverrideWithDelegation.kt"); + } + + @Test + @TestMetadata("fakeOverrideFromInterfaceThroughIntermediateClass.kt") + public void testFakeOverrideFromInterfaceThroughIntermediateClass() throws Exception { + runTest("compiler/testData/codegen/box/bridges/fakeOverrideFromInterfaceThroughIntermediateClass.kt"); + } + + @Test + @TestMetadata("fakeOverrideMultiFile.kt") + public void testFakeOverrideMultiFile() throws Exception { + runTest("compiler/testData/codegen/box/bridges/fakeOverrideMultiFile.kt"); + } + + @Test + @TestMetadata("fakeOverrideOfTraitImpl.kt") + public void testFakeOverrideOfTraitImpl() throws Exception { + runTest("compiler/testData/codegen/box/bridges/fakeOverrideOfTraitImpl.kt"); + } + + @Test + @TestMetadata("fakeOverrideThroughGenericSuperclass.kt") + public void testFakeOverrideThroughGenericSuperclass() throws Exception { + runTest("compiler/testData/codegen/box/bridges/fakeOverrideThroughGenericSuperclass.kt"); + } + + @Test + @TestMetadata("fakeOverrideWithSeveralSuperDeclarations.kt") + public void testFakeOverrideWithSeveralSuperDeclarations() throws Exception { + runTest("compiler/testData/codegen/box/bridges/fakeOverrideWithSeveralSuperDeclarations.kt"); + } + + @Test + @TestMetadata("fakeOverrideWithSynthesizedImplementation.kt") + public void testFakeOverrideWithSynthesizedImplementation() throws Exception { + runTest("compiler/testData/codegen/box/bridges/fakeOverrideWithSynthesizedImplementation.kt"); + } + + @Test + @TestMetadata("genericProperty.kt") + public void testGenericProperty() throws Exception { + runTest("compiler/testData/codegen/box/bridges/genericProperty.kt"); + } + + @Test + @TestMetadata("innerClassTypeParameters.kt") + public void testInnerClassTypeParameters() throws Exception { + runTest("compiler/testData/codegen/box/bridges/innerClassTypeParameters.kt"); + } + + @Test + @TestMetadata("kt12416.kt") + public void testKt12416() throws Exception { + runTest("compiler/testData/codegen/box/bridges/kt12416.kt"); + } + + @Test + @TestMetadata("kt1939.kt") + public void testKt1939() throws Exception { + runTest("compiler/testData/codegen/box/bridges/kt1939.kt"); + } + + @Test + @TestMetadata("kt1959.kt") + public void testKt1959() throws Exception { + runTest("compiler/testData/codegen/box/bridges/kt1959.kt"); + } + + @Test + @TestMetadata("kt2498.kt") + public void testKt2498() throws Exception { + runTest("compiler/testData/codegen/box/bridges/kt2498.kt"); + } + + @Test + @TestMetadata("kt2702.kt") + public void testKt2702() throws Exception { + runTest("compiler/testData/codegen/box/bridges/kt2702.kt"); + } + + @Test + @TestMetadata("kt2833.kt") + public void testKt2833() throws Exception { + runTest("compiler/testData/codegen/box/bridges/kt2833.kt"); + } + + @Test + @TestMetadata("kt2920.kt") + public void testKt2920() throws Exception { + runTest("compiler/testData/codegen/box/bridges/kt2920.kt"); + } + + @Test + @TestMetadata("kt318.kt") + public void testKt318() throws Exception { + runTest("compiler/testData/codegen/box/bridges/kt318.kt"); + } + + @Test + @TestMetadata("kt42137.kt") + public void testKt42137() throws Exception { + runTest("compiler/testData/codegen/box/bridges/kt42137.kt"); + } + + @Test + @TestMetadata("kt46389.kt") + public void testKt46389() throws Exception { + runTest("compiler/testData/codegen/box/bridges/kt46389.kt"); + } + + @Test + @TestMetadata("kt46389_jvmDefault.kt") + public void testKt46389_jvmDefault() throws Exception { + runTest("compiler/testData/codegen/box/bridges/kt46389_jvmDefault.kt"); + } + + @Test + @TestMetadata("longChainOneBridge.kt") + public void testLongChainOneBridge() throws Exception { + runTest("compiler/testData/codegen/box/bridges/longChainOneBridge.kt"); + } + + @Test + @TestMetadata("manyTypeArgumentsSubstitutedSuccessively.kt") + public void testManyTypeArgumentsSubstitutedSuccessively() throws Exception { + runTest("compiler/testData/codegen/box/bridges/manyTypeArgumentsSubstitutedSuccessively.kt"); + } + + @Test + @TestMetadata("methodFromTrait.kt") + public void testMethodFromTrait() throws Exception { + runTest("compiler/testData/codegen/box/bridges/methodFromTrait.kt"); + } + + @Test + @TestMetadata("methodWithDefaultParameter.kt") + public void testMethodWithDefaultParameter() throws Exception { + runTest("compiler/testData/codegen/box/bridges/methodWithDefaultParameter.kt"); + } + + @Test + @TestMetadata("nestedClassTypeParameters.kt") + public void testNestedClassTypeParameters() throws Exception { + runTest("compiler/testData/codegen/box/bridges/nestedClassTypeParameters.kt"); + } + + @Test + @TestMetadata("noBridgeOnMutableCollectionInheritance.kt") + public void testNoBridgeOnMutableCollectionInheritance() throws Exception { + runTest("compiler/testData/codegen/box/bridges/noBridgeOnMutableCollectionInheritance.kt"); + } + + @Test + @TestMetadata("overrideAbstractProperty.kt") + public void testOverrideAbstractProperty() throws Exception { + runTest("compiler/testData/codegen/box/bridges/overrideAbstractProperty.kt"); + } + + @Test + @TestMetadata("overrideReturnType.kt") + public void testOverrideReturnType() throws Exception { + runTest("compiler/testData/codegen/box/bridges/overrideReturnType.kt"); + } + + @Test + @TestMetadata("overrideWithValueClassReturn.kt") + public void testOverrideWithValueClassReturn() throws Exception { + runTest("compiler/testData/codegen/box/bridges/overrideWithValueClassReturn.kt"); + } + + @Test + @TestMetadata("propertyAccessorsWithoutBody.kt") + public void testPropertyAccessorsWithoutBody() throws Exception { + runTest("compiler/testData/codegen/box/bridges/propertyAccessorsWithoutBody.kt"); + } + + @Test + @TestMetadata("propertyDiamond.kt") + public void testPropertyDiamond() throws Exception { + runTest("compiler/testData/codegen/box/bridges/propertyDiamond.kt"); + } + + @Test + @TestMetadata("propertyDiamondFakeOverride.kt") + public void testPropertyDiamondFakeOverride() throws Exception { + runTest("compiler/testData/codegen/box/bridges/propertyDiamondFakeOverride.kt"); + } + + @Test + @TestMetadata("propertyInConstructor.kt") + public void testPropertyInConstructor() throws Exception { + runTest("compiler/testData/codegen/box/bridges/propertyInConstructor.kt"); + } + + @Test + @TestMetadata("propertySetter.kt") + public void testPropertySetter() throws Exception { + runTest("compiler/testData/codegen/box/bridges/propertySetter.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/bridges/simple.kt"); + } + + @Test + @TestMetadata("simpleEnum.kt") + public void testSimpleEnum() throws Exception { + runTest("compiler/testData/codegen/box/bridges/simpleEnum.kt"); + } + + @Test + @TestMetadata("simpleGenericMethod.kt") + public void testSimpleGenericMethod() throws Exception { + runTest("compiler/testData/codegen/box/bridges/simpleGenericMethod.kt"); + } + + @Test + @TestMetadata("simpleObject.kt") + public void testSimpleObject() throws Exception { + runTest("compiler/testData/codegen/box/bridges/simpleObject.kt"); + } + + @Test + @TestMetadata("simpleReturnType.kt") + public void testSimpleReturnType() throws Exception { + runTest("compiler/testData/codegen/box/bridges/simpleReturnType.kt"); + } + + @Test + @TestMetadata("simpleTraitImpl.kt") + public void testSimpleTraitImpl() throws Exception { + runTest("compiler/testData/codegen/box/bridges/simpleTraitImpl.kt"); + } + + @Test + @TestMetadata("simpleUpperBound.kt") + public void testSimpleUpperBound() throws Exception { + runTest("compiler/testData/codegen/box/bridges/simpleUpperBound.kt"); + } + + @Test + @TestMetadata("strListContains.kt") + public void testStrListContains() throws Exception { + runTest("compiler/testData/codegen/box/bridges/strListContains.kt"); + } + + @Test + @TestMetadata("traitImplInheritsTraitImpl.kt") + public void testTraitImplInheritsTraitImpl() throws Exception { + runTest("compiler/testData/codegen/box/bridges/traitImplInheritsTraitImpl.kt"); + } + + @Test + @TestMetadata("twoParentsWithDifferentMethodsTwoBridges.kt") + public void testTwoParentsWithDifferentMethodsTwoBridges() throws Exception { + runTest("compiler/testData/codegen/box/bridges/twoParentsWithDifferentMethodsTwoBridges.kt"); + } + + @Test + @TestMetadata("twoParentsWithDifferentMethodsTwoBridges2.kt") + public void testTwoParentsWithDifferentMethodsTwoBridges2() throws Exception { + runTest("compiler/testData/codegen/box/bridges/twoParentsWithDifferentMethodsTwoBridges2.kt"); + } + + @Test + @TestMetadata("twoParentsWithTheSameMethodOneBridge.kt") + public void testTwoParentsWithTheSameMethodOneBridge() throws Exception { + runTest("compiler/testData/codegen/box/bridges/twoParentsWithTheSameMethodOneBridge.kt"); + } + + @Test + @TestMetadata("typeParameterInExtensionReceiver.kt") + public void testTypeParameterInExtensionReceiver() throws Exception { + runTest("compiler/testData/codegen/box/bridges/typeParameterInExtensionReceiver.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/bridges/substitutionInSuperClass") + @TestDataPath("$PROJECT_ROOT") + public class SubstitutionInSuperClass { + @Test + @TestMetadata("abstractFun.kt") + public void testAbstractFun() throws Exception { + runTest("compiler/testData/codegen/box/bridges/substitutionInSuperClass/abstractFun.kt"); + } + + @Test + public void testAllFilesPresentInSubstitutionInSuperClass() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/bridges/substitutionInSuperClass"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("boundedTypeArguments.kt") + public void testBoundedTypeArguments() throws Exception { + runTest("compiler/testData/codegen/box/bridges/substitutionInSuperClass/boundedTypeArguments.kt"); + } + + @Test + @TestMetadata("delegation.kt") + public void testDelegation() throws Exception { + runTest("compiler/testData/codegen/box/bridges/substitutionInSuperClass/delegation.kt"); + } + + @Test + @TestMetadata("differentErasureInSuperClass.kt") + public void testDifferentErasureInSuperClass() throws Exception { + runTest("compiler/testData/codegen/box/bridges/substitutionInSuperClass/differentErasureInSuperClass.kt"); + } + + @Test + @TestMetadata("differentErasureInSuperClassComplex.kt") + public void testDifferentErasureInSuperClassComplex() throws Exception { + runTest("compiler/testData/codegen/box/bridges/substitutionInSuperClass/differentErasureInSuperClassComplex.kt"); + } + + @Test + @TestMetadata("enum.kt") + public void testEnum() throws Exception { + runTest("compiler/testData/codegen/box/bridges/substitutionInSuperClass/enum.kt"); + } + + @Test + @TestMetadata("genericMethod.kt") + public void testGenericMethod() throws Exception { + runTest("compiler/testData/codegen/box/bridges/substitutionInSuperClass/genericMethod.kt"); + } + + @Test + @TestMetadata("object.kt") + public void testObject() throws Exception { + runTest("compiler/testData/codegen/box/bridges/substitutionInSuperClass/object.kt"); + } + + @Test + @TestMetadata("property.kt") + public void testProperty() throws Exception { + runTest("compiler/testData/codegen/box/bridges/substitutionInSuperClass/property.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/bridges/substitutionInSuperClass/simple.kt"); + } + + @Test + @TestMetadata("upperBound.kt") + public void testUpperBound() throws Exception { + runTest("compiler/testData/codegen/box/bridges/substitutionInSuperClass/upperBound.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builtinStubMethods") + @TestDataPath("$PROJECT_ROOT") + public class BuiltinStubMethods { + @Test + public void testAllFilesPresentInBuiltinStubMethods() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("customReadOnlyIterator.kt") + public void testCustomReadOnlyIterator() throws Exception { + runTest("compiler/testData/codegen/box/builtinStubMethods/customReadOnlyIterator.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builtinStubMethods/bridgesForStubs") + @TestDataPath("$PROJECT_ROOT") + public class BridgesForStubs { + @Test + public void testAllFilesPresentInBridgesForStubs() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/bridgesForStubs"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builtinStubMethods/extendJavaClasses") + @TestDataPath("$PROJECT_ROOT") + public class ExtendJavaClasses { + @Test + @TestMetadata("abstractSet.kt") + public void testAbstractSet() throws Exception { + runTest("compiler/testData/codegen/box/builtinStubMethods/extendJavaClasses/abstractSet.kt"); + } + + @Test + public void testAllFilesPresentInExtendJavaClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/extendJavaClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("arrayList.kt") + public void testArrayList() throws Exception { + runTest("compiler/testData/codegen/box/builtinStubMethods/extendJavaClasses/arrayList.kt"); + } + + @Test + @TestMetadata("extendArrayListThroughKotlin.kt") + public void testExtendArrayListThroughKotlin() throws Exception { + runTest("compiler/testData/codegen/box/builtinStubMethods/extendJavaClasses/extendArrayListThroughKotlin.kt"); + } + + @Test + @TestMetadata("hashMap.kt") + public void testHashMap() throws Exception { + runTest("compiler/testData/codegen/box/builtinStubMethods/extendJavaClasses/hashMap.kt"); + } + + @Test + @TestMetadata("hashSet.kt") + public void testHashSet() throws Exception { + runTest("compiler/testData/codegen/box/builtinStubMethods/extendJavaClasses/hashSet.kt"); + } + + @Test + @TestMetadata("overrideAbstractSetMethod.kt") + public void testOverrideAbstractSetMethod() throws Exception { + runTest("compiler/testData/codegen/box/builtinStubMethods/extendJavaClasses/overrideAbstractSetMethod.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builtinStubMethods/mapGetOrDefault") + @TestDataPath("$PROJECT_ROOT") + public class MapGetOrDefault { + @Test + public void testAllFilesPresentInMapGetOrDefault() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapGetOrDefault"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/builtinStubMethods/mapRemove") + @TestDataPath("$PROJECT_ROOT") + public class MapRemove { + @Test + public void testAllFilesPresentInMapRemove() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/builtinStubMethods/mapRemove"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/callableReference") + @TestDataPath("$PROJECT_ROOT") + public class CallableReference { + @Test + public void testAllFilesPresentInCallableReference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("arrayConstructor.kt") + public void testArrayConstructor() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/arrayConstructor.kt"); + } + + @Test + @TestMetadata("arrayConstructorArgument.kt") + public void testArrayConstructorArgument() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/arrayConstructorArgument.kt"); + } + + @Test + @TestMetadata("arrayOf.kt") + public void testArrayOf() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/arrayOf.kt"); + } + + @Test + @TestMetadata("callableReferenceOfCompanionConst.kt") + public void testCallableReferenceOfCompanionConst() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/callableReferenceOfCompanionConst.kt"); + } + + @Test + @TestMetadata("callableReferenceOfCompanionMethod.kt") + public void testCallableReferenceOfCompanionMethod() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/callableReferenceOfCompanionMethod.kt"); + } + + @Test + @TestMetadata("callableReferenceOfCompanionProperty.kt") + public void testCallableReferenceOfCompanionProperty() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/callableReferenceOfCompanionProperty.kt"); + } + + @Test + @TestMetadata("callableReferenceOfKotlinNestedClass.kt") + public void testCallableReferenceOfKotlinNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/callableReferenceOfKotlinNestedClass.kt"); + } + + @Test + @TestMetadata("callableReferenceOfObjectMethod.kt") + public void testCallableReferenceOfObjectMethod() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/callableReferenceOfObjectMethod.kt"); + } + + @Test + @TestMetadata("charArrayOf.kt") + public void testCharArrayOf() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/charArrayOf.kt"); + } + + @Test + @TestMetadata("genericConstructorReference.kt") + public void testGenericConstructorReference() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/genericConstructorReference.kt"); + } + + @Test + @TestMetadata("genericLocalClassConstructorReference.kt") + public void testGenericLocalClassConstructorReference() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/genericLocalClassConstructorReference.kt"); + } + + @Test + @TestMetadata("inlineArrayConstructors.kt") + public void testInlineArrayConstructors() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/inlineArrayConstructors.kt"); + } + + @Test + @TestMetadata("kt21014.kt") + public void testKt21014() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/kt21014.kt"); + } + + @Test + @TestMetadata("kt21092a.kt") + public void testKt21092a() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/kt21092a.kt"); + } + + @Test + @TestMetadata("kt37604.kt") + public void testKt37604() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/kt37604.kt"); + } + + @Test + @TestMetadata("kt44483.kt") + public void testKt44483() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/kt44483.kt"); + } + + @Test + @TestMetadata("kt46902.kt") + public void testKt46902() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/kt46902.kt"); + } + + @Test + @TestMetadata("kt47988.kt") + public void testKt47988() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/kt47988.kt"); + } + + @Test + @TestMetadata("kt49526.kt") + public void testKt49526() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/kt49526.kt"); + } + + @Test + @TestMetadata("kt49526_sam.kt") + public void testKt49526_sam() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/kt49526_sam.kt"); + } + + @Test + @TestMetadata("kt49526a.kt") + public void testKt49526a() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/kt49526a.kt"); + } + + @Test + @TestMetadata("kt49526b.kt") + public void testKt49526b() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/kt49526b.kt"); + } + + @Test + @TestMetadata("kt50172.kt") + public void testKt50172() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/kt50172.kt"); + } + + @Test + @TestMetadata("kt51844.kt") + public void testKt51844() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/kt51844.kt"); + } + + @Test + @TestMetadata("kt52270.kt") + public void testKt52270() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/kt52270.kt"); + } + + @Test + @TestMetadata("nested.kt") + public void testNested() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/nested.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/callableReference/adaptedReferences") + @TestDataPath("$PROJECT_ROOT") + public class AdaptedReferences { + @Test + @TestMetadata("adaptedArrayOf.kt") + public void testAdaptedArrayOf() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/adaptedArrayOf.kt"); + } + + @Test + @TestMetadata("adaptedVarargFunImportedFromObject.kt") + public void testAdaptedVarargFunImportedFromObject() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/adaptedVarargFunImportedFromObject.kt"); + } + + @Test + public void testAllFilesPresentInAdaptedReferences() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("bothWithCoercionToUnit.kt") + public void testBothWithCoercionToUnit() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/bothWithCoercionToUnit.kt"); + } + + @Test + @TestMetadata("boundReferences.kt") + public void testBoundReferences() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/boundReferences.kt"); + } + + @Test + @TestMetadata("defaultAfterVararg.kt") + public void testDefaultAfterVararg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/defaultAfterVararg.kt"); + } + + @Test + @TestMetadata("defaultWithGenericExpectedType.kt") + public void testDefaultWithGenericExpectedType() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/defaultWithGenericExpectedType.kt"); + } + + @Test + @TestMetadata("emptyVarargAndDefault.kt") + public void testEmptyVarargAndDefault() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/emptyVarargAndDefault.kt"); + } + + @Test + @TestMetadata("inlineBound.kt") + public void testInlineBound() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/inlineBound.kt"); + } + + @Test + @TestMetadata("inlineDefault.kt") + public void testInlineDefault() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/inlineDefault.kt"); + } + + @Test + @TestMetadata("inlineVararg.kt") + public void testInlineVararg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/inlineVararg.kt"); + } + + @Test + @TestMetadata("inlineVarargAndDefault.kt") + public void testInlineVarargAndDefault() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/inlineVarargAndDefault.kt"); + } + + @Test + @TestMetadata("inlineVarargInts.kt") + public void testInlineVarargInts() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/inlineVarargInts.kt"); + } + + @Test + @TestMetadata("innerConstructorWithVararg.kt") + public void testInnerConstructorWithVararg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/innerConstructorWithVararg.kt"); + } + + @Test + @TestMetadata("largeVararg.kt") + public void testLargeVararg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/largeVararg.kt"); + } + + @Test + @TestMetadata("localFunctionWithDefault.kt") + public void testLocalFunctionWithDefault() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/localFunctionWithDefault.kt"); + } + + @Test + @TestMetadata("manyDefaultsAndVararg.kt") + public void testManyDefaultsAndVararg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/manyDefaultsAndVararg.kt"); + } + + @Test + @TestMetadata("nestedClassConstructorWithDefault.kt") + public void testNestedClassConstructorWithDefault() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/nestedClassConstructorWithDefault.kt"); + } + + @Test + @TestMetadata("noNameClashForReferencesToSameFunction.kt") + public void testNoNameClashForReferencesToSameFunction() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/noNameClashForReferencesToSameFunction.kt"); + } + + @Test + @TestMetadata("referenceToVarargWithDefaults.kt") + public void testReferenceToVarargWithDefaults() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/referenceToVarargWithDefaults.kt"); + } + + @Test + @TestMetadata("simpleDefaultArgument.kt") + public void testSimpleDefaultArgument() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/simpleDefaultArgument.kt"); + } + + @Test + @TestMetadata("simpleEmptyVararg.kt") + public void testSimpleEmptyVararg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/simpleEmptyVararg.kt"); + } + + @Test + @TestMetadata("suspendUnitConversion.kt") + public void testSuspendUnitConversion() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendUnitConversion.kt"); + } + + @Test + @TestMetadata("unboundReferences.kt") + public void testUnboundReferences() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/unboundReferences.kt"); + } + + @Test + @TestMetadata("varargFromBaseClass.kt") + public void testVarargFromBaseClass() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/varargFromBaseClass.kt"); + } + + @Test + @TestMetadata("varargViewedAsArray.kt") + public void testVarargViewedAsArray() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/varargViewedAsArray.kt"); + } + + @Test + @TestMetadata("varargViewedAsPrimitiveArray.kt") + public void testVarargViewedAsPrimitiveArray() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/varargViewedAsPrimitiveArray.kt"); + } + + @Test + @TestMetadata("varargWithDefaultValue.kt") + public void testVarargWithDefaultValue() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/varargWithDefaultValue.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion") + @TestDataPath("$PROJECT_ROOT") + public class SuspendConversion { + @Test + @TestMetadata("adaptedWithCoercionToUnit.kt") + public void testAdaptedWithCoercionToUnit() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/adaptedWithCoercionToUnit.kt"); + } + + @Test + @TestMetadata("adaptedWithDefaultArguments.kt") + public void testAdaptedWithDefaultArguments() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/adaptedWithDefaultArguments.kt"); + } + + @Test + @TestMetadata("adaptedWithVarargs.kt") + public void testAdaptedWithVarargs() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/adaptedWithVarargs.kt"); + } + + @Test + public void testAllFilesPresentInSuspendConversion() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("bound.kt") + public void testBound() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/bound.kt"); + } + + @Test + @TestMetadata("boundExtension.kt") + public void testBoundExtension() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/boundExtension.kt"); + } + + @Test + @TestMetadata("crossInline.kt") + public void testCrossInline() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/crossInline.kt"); + } + + @Test + @TestMetadata("inlineAdaptedWithCoercionToUnit.kt") + public void testInlineAdaptedWithCoercionToUnit() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/inlineAdaptedWithCoercionToUnit.kt"); + } + + @Test + @TestMetadata("inlineAdaptedWithDefaultArguments.kt") + public void testInlineAdaptedWithDefaultArguments() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/inlineAdaptedWithDefaultArguments.kt"); + } + + @Test + @TestMetadata("inlineAdaptedWithVarargs.kt") + public void testInlineAdaptedWithVarargs() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/inlineAdaptedWithVarargs.kt"); + } + + @Test + @TestMetadata("inlineBound.kt") + public void testInlineBound() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/inlineBound.kt"); + } + + @Test + @TestMetadata("inlineSimple.kt") + public void testInlineSimple() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/inlineSimple.kt"); + } + + @Test + @TestMetadata("inlineWithParameters.kt") + public void testInlineWithParameters() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/inlineWithParameters.kt"); + } + + @Test + @TestMetadata("isAs.kt") + public void testIsAs() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/isAs.kt"); + } + + @Test + @TestMetadata("nullableParameter.kt") + public void testNullableParameter() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/nullableParameter.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/simple.kt"); + } + + @Test + @TestMetadata("withParameters.kt") + public void testWithParameters() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/adaptedReferences/suspendConversion/withParameters.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/callableReference/bound") + @TestDataPath("$PROJECT_ROOT") + public class Bound { + @Test + @TestMetadata("adapted.kt") + public void testAdapted() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/adapted.kt"); + } + + @Test + public void testAllFilesPresentInBound() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("array.kt") + public void testArray() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/array.kt"); + } + + @Test + @TestMetadata("arrayConstructorArgument.kt") + public void testArrayConstructorArgument() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/arrayConstructorArgument.kt"); + } + + @Test + @TestMetadata("arrayGetIntrinsic.kt") + public void testArrayGetIntrinsic() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/arrayGetIntrinsic.kt"); + } + + @Test + @TestMetadata("boundReferenceToOverloadedFunction.kt") + public void testBoundReferenceToOverloadedFunction() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/boundReferenceToOverloadedFunction.kt"); + } + + @Test + @TestMetadata("captureVarInInitBlock.kt") + public void testCaptureVarInInitBlock() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/captureVarInInitBlock.kt"); + } + + @Test + @TestMetadata("captureVarInPropertyInit.kt") + public void testCaptureVarInPropertyInit() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/captureVarInPropertyInit.kt"); + } + + @Test + @TestMetadata("coercionToUnit.kt") + public void testCoercionToUnit() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/coercionToUnit.kt"); + } + + @Test + @TestMetadata("companionObjectReceiver.kt") + public void testCompanionObjectReceiver() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/companionObjectReceiver.kt"); + } + + @Test + @TestMetadata("companionObjectReceiverInheritsFromOuter.kt") + public void testCompanionObjectReceiverInheritsFromOuter() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/companionObjectReceiverInheritsFromOuter.kt"); + } + + @Test + @TestMetadata("dontShareReceiver.kt") + public void testDontShareReceiver() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/dontShareReceiver.kt"); + } + + @Test + @TestMetadata("emptyLHS.kt") + public void testEmptyLHS() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/emptyLHS.kt"); + } + + @Test + @TestMetadata("enumEntryMember.kt") + public void testEnumEntryMember() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/enumEntryMember.kt"); + } + + @Test + @TestMetadata("genericBoundPropertyAsCrossinline.kt") + public void testGenericBoundPropertyAsCrossinline() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/genericBoundPropertyAsCrossinline.kt"); + } + + @Test + @TestMetadata("genericValOnLHS.kt") + public void testGenericValOnLHS() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/genericValOnLHS.kt"); + } + + @Test + @TestMetadata("kCallableNameIntrinsic.kt") + public void testKCallableNameIntrinsic() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/kCallableNameIntrinsic.kt"); + } + + @Test + @TestMetadata("kt12738.kt") + public void testKt12738() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/kt12738.kt"); + } + + @Test + @TestMetadata("kt15446.kt") + public void testKt15446() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/kt15446.kt"); + } + + @Test + @TestMetadata("kt44636_localExtension.kt") + public void testKt44636_localExtension() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/kt44636_localExtension.kt"); + } + + @Test + @TestMetadata("multiCase.kt") + public void testMultiCase() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/multiCase.kt"); + } + + @Test + @TestMetadata("nullReceiver.kt") + public void testNullReceiver() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/nullReceiver.kt"); + } + + @Test + @TestMetadata("objectReceiver.kt") + public void testObjectReceiver() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/objectReceiver.kt"); + } + + @Test + @TestMetadata("primitiveReceiver.kt") + public void testPrimitiveReceiver() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/primitiveReceiver.kt"); + } + + @Test + @TestMetadata("receiverEvaluatedOnce.kt") + public void testReceiverEvaluatedOnce() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/receiverEvaluatedOnce.kt"); + } + + @Test + @TestMetadata("simpleFunction.kt") + public void testSimpleFunction() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/simpleFunction.kt"); + } + + @Test + @TestMetadata("simpleProperty.kt") + public void testSimpleProperty() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/simpleProperty.kt"); + } + + @Test + @TestMetadata("smartCastForExtensionReceiver.kt") + public void testSmartCastForExtensionReceiver() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/smartCastForExtensionReceiver.kt"); + } + + @Test + @TestMetadata("typeAliasObjectBoundReference.kt") + public void testTypeAliasObjectBoundReference() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/typeAliasObjectBoundReference.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/callableReference/bound/equals") + @TestDataPath("$PROJECT_ROOT") + public class Equals { + @Test + public void testAllFilesPresentInEquals() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/bound/equals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("nullableReceiverInEquals.kt") + public void testNullableReceiverInEquals() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/equals/nullableReceiverInEquals.kt"); + } + + @Test + @TestMetadata("receiverInEquals.kt") + public void testReceiverInEquals() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/bound/equals/receiverInEquals.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/callableReference/equality") + @TestDataPath("$PROJECT_ROOT") + public class Equality { + @Test + public void testAllFilesPresentInEquality() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/equality"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("capturedDefaults.kt") + public void testCapturedDefaults() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/equality/capturedDefaults.kt"); + } + + @Test + @TestMetadata("capturedVararg.kt") + public void testCapturedVararg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/equality/capturedVararg.kt"); + } + + @Test + @TestMetadata("coercionToUnit.kt") + public void testCoercionToUnit() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/equality/coercionToUnit.kt"); + } + + @Test + @TestMetadata("coercionToUnitWithDefaults.kt") + public void testCoercionToUnitWithDefaults() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/equality/coercionToUnitWithDefaults.kt"); + } + + @Test + @TestMetadata("coercionToUnitWithVararg.kt") + public void testCoercionToUnitWithVararg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/equality/coercionToUnitWithVararg.kt"); + } + + @Test + @TestMetadata("conversionCombinations.kt") + public void testConversionCombinations() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/equality/conversionCombinations.kt"); + } + + @Test + @TestMetadata("extensionReceiverVsDefault.kt") + public void testExtensionReceiverVsDefault() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/equality/extensionReceiverVsDefault.kt"); + } + + @Test + @TestMetadata("noCoercionToUnitIfFunctionAlreadyReturnsUnit.kt") + public void testNoCoercionToUnitIfFunctionAlreadyReturnsUnit() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/equality/noCoercionToUnitIfFunctionAlreadyReturnsUnit.kt"); + } + + @Test + @TestMetadata("simpleEquality.kt") + public void testSimpleEquality() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/equality/simpleEquality.kt"); + } + + @Test + @TestMetadata("suspendConversion.kt") + public void testSuspendConversion() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/equality/suspendConversion.kt"); + } + + @Test + @TestMetadata("varargAsArrayMemberOrExtension.kt") + public void testVarargAsArrayMemberOrExtension() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/equality/varargAsArrayMemberOrExtension.kt"); + } + + @Test + @TestMetadata("varargAsArrayWithDefaults.kt") + public void testVarargAsArrayWithDefaults() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/equality/varargAsArrayWithDefaults.kt"); + } + + @Test + @TestMetadata("varargWithDefaults.kt") + public void testVarargWithDefaults() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/equality/varargWithDefaults.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/callableReference/funInterfaceConstructor") + @TestDataPath("$PROJECT_ROOT") + public class FunInterfaceConstructor { + @Test + public void testAllFilesPresentInFunInterfaceConstructor() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/funInterfaceConstructor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("funInterfaceConstructedObjectsEquality.kt") + public void testFunInterfaceConstructedObjectsEquality() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/funInterfaceConstructor/funInterfaceConstructedObjectsEquality.kt"); + } + + @Test + @TestMetadata("funInterfaceConstructor.kt") + public void testFunInterfaceConstructor() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/funInterfaceConstructor/funInterfaceConstructor.kt"); + } + + @Test + @TestMetadata("funInterfaceConstructorEquality.kt") + public void testFunInterfaceConstructorEquality() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/funInterfaceConstructor/funInterfaceConstructorEquality.kt"); + } + + @Test + @TestMetadata("funInterfaceConstructorIsKFunction.kt") + public void testFunInterfaceConstructorIsKFunction() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/funInterfaceConstructor/funInterfaceConstructorIsKFunction.kt"); + } + + @Test + @TestMetadata("funInterfaceConstructorOfImplicitKFunctionType.kt") + public void testFunInterfaceConstructorOfImplicitKFunctionType() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/funInterfaceConstructor/funInterfaceConstructorOfImplicitKFunctionType.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/callableReference/function") + @TestDataPath("$PROJECT_ROOT") + public class Function { + @Test + @TestMetadata("abstractClassMember.kt") + public void testAbstractClassMember() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/abstractClassMember.kt"); + } + + @Test + public void testAllFilesPresentInFunction() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("argumentTypes.kt") + public void testArgumentTypes() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/argumentTypes.kt"); + } + + @Test + @TestMetadata("argumentTypesNoinline.kt") + public void testArgumentTypesNoinline() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/argumentTypesNoinline.kt"); + } + + @Test + @TestMetadata("booleanNotIntrinsic.kt") + public void testBooleanNotIntrinsic() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/booleanNotIntrinsic.kt"); + } + + @Test + @TestMetadata("classMemberFromClass.kt") + public void testClassMemberFromClass() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/classMemberFromClass.kt"); + } + + @Test + @TestMetadata("classMemberFromCompanionObject.kt") + public void testClassMemberFromCompanionObject() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/classMemberFromCompanionObject.kt"); + } + + @Test + @TestMetadata("classMemberFromExtension.kt") + public void testClassMemberFromExtension() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/classMemberFromExtension.kt"); + } + + @Test + @TestMetadata("classMemberFromTopLevelStringNoArgs.kt") + public void testClassMemberFromTopLevelStringNoArgs() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/classMemberFromTopLevelStringNoArgs.kt"); + } + + @Test + @TestMetadata("classMemberFromTopLevelStringOneStringArg.kt") + public void testClassMemberFromTopLevelStringOneStringArg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/classMemberFromTopLevelStringOneStringArg.kt"); + } + + @Test + @TestMetadata("classMemberFromTopLevelUnitNoArgs.kt") + public void testClassMemberFromTopLevelUnitNoArgs() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/classMemberFromTopLevelUnitNoArgs.kt"); + } + + @Test + @TestMetadata("classMemberFromTopLevelUnitOneStringArg.kt") + public void testClassMemberFromTopLevelUnitOneStringArg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/classMemberFromTopLevelUnitOneStringArg.kt"); + } + + @Test + @TestMetadata("coercionToUnit.kt") + public void testCoercionToUnit() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/coercionToUnit.kt"); + } + + @Test + @TestMetadata("constructorFromTopLevelNoArgs.kt") + public void testConstructorFromTopLevelNoArgs() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/constructorFromTopLevelNoArgs.kt"); + } + + @Test + @TestMetadata("constructorFromTopLevelOneStringArg.kt") + public void testConstructorFromTopLevelOneStringArg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/constructorFromTopLevelOneStringArg.kt"); + } + + @Test + @TestMetadata("enumValueOfMethod.kt") + public void testEnumValueOfMethod() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/enumValueOfMethod.kt"); + } + + @Test + @TestMetadata("equalsIntrinsic.kt") + public void testEqualsIntrinsic() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/equalsIntrinsic.kt"); + } + + @Test + @TestMetadata("extensionFromClass.kt") + public void testExtensionFromClass() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/extensionFromClass.kt"); + } + + @Test + @TestMetadata("extensionFromExtension.kt") + public void testExtensionFromExtension() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/extensionFromExtension.kt"); + } + + @Test + @TestMetadata("extensionFromTopLevelStringNoArgs.kt") + public void testExtensionFromTopLevelStringNoArgs() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/extensionFromTopLevelStringNoArgs.kt"); + } + + @Test + @TestMetadata("extensionFromTopLevelStringOneStringArg.kt") + public void testExtensionFromTopLevelStringOneStringArg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/extensionFromTopLevelStringOneStringArg.kt"); + } + + @Test + @TestMetadata("extensionFromTopLevelUnitNoArgs.kt") + public void testExtensionFromTopLevelUnitNoArgs() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/extensionFromTopLevelUnitNoArgs.kt"); + } + + @Test + @TestMetadata("extensionFromTopLevelUnitOneStringArg.kt") + public void testExtensionFromTopLevelUnitOneStringArg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/extensionFromTopLevelUnitOneStringArg.kt"); + } + + @Test + @TestMetadata("genericCallableReferenceArgumentsNonJVM.kt") + public void testGenericCallableReferenceArgumentsNonJVM() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/genericCallableReferenceArgumentsNonJVM.kt"); + } + + @Test + @TestMetadata("genericCallableReferenceWithReifiedTypeParam.kt") + public void testGenericCallableReferenceWithReifiedTypeParam() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/genericCallableReferenceWithReifiedTypeParam.kt"); + } + + @Test + @TestMetadata("genericCallableReferencesWithNullableTypes.kt") + public void testGenericCallableReferencesWithNullableTypes() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/genericCallableReferencesWithNullableTypes.kt"); + } + + @Test + @TestMetadata("genericCallableReferencesWithOverload.kt") + public void testGenericCallableReferencesWithOverload() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/genericCallableReferencesWithOverload.kt"); + } + + @Test + @TestMetadata("genericMember.kt") + public void testGenericMember() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/genericMember.kt"); + } + + @Test + @TestMetadata("genericWithDependentType.kt") + public void testGenericWithDependentType() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/genericWithDependentType.kt"); + } + + @Test + @TestMetadata("innerClassConstructorWithTwoReceivers.kt") + public void testInnerClassConstructorWithTwoReceivers() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/innerClassConstructorWithTwoReceivers.kt"); + } + + @Test + @TestMetadata("innerConstructorFromClass.kt") + public void testInnerConstructorFromClass() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/innerConstructorFromClass.kt"); + } + + @Test + @TestMetadata("innerConstructorFromExtension.kt") + public void testInnerConstructorFromExtension() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/innerConstructorFromExtension.kt"); + } + + @Test + @TestMetadata("innerConstructorFromTopLevelNoArgs.kt") + public void testInnerConstructorFromTopLevelNoArgs() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/innerConstructorFromTopLevelNoArgs.kt"); + } + + @Test + @TestMetadata("innerConstructorFromTopLevelOneStringArg.kt") + public void testInnerConstructorFromTopLevelOneStringArg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/innerConstructorFromTopLevelOneStringArg.kt"); + } + + @Test + @TestMetadata("kt21787.kt") + public void testKt21787() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/kt21787.kt"); + } + + @Test + @TestMetadata("kt32462.kt") + public void testKt32462() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/kt32462.kt"); + } + + @Test + @TestMetadata("kt47741.kt") + public void testKt47741() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/kt47741.kt"); + } + + @Test + @TestMetadata("nestedConstructorFromClass.kt") + public void testNestedConstructorFromClass() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/nestedConstructorFromClass.kt"); + } + + @Test + @TestMetadata("nestedConstructorFromTopLevelNoArgs.kt") + public void testNestedConstructorFromTopLevelNoArgs() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/nestedConstructorFromTopLevelNoArgs.kt"); + } + + @Test + @TestMetadata("nestedConstructorFromTopLevelOneStringArg.kt") + public void testNestedConstructorFromTopLevelOneStringArg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/nestedConstructorFromTopLevelOneStringArg.kt"); + } + + @Test + @TestMetadata("newArray.kt") + public void testNewArray() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/newArray.kt"); + } + + @Test + @TestMetadata("overloadedFun.kt") + public void testOverloadedFun() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/overloadedFun.kt"); + } + + @Test + @TestMetadata("overloadedFunVsVal.kt") + public void testOverloadedFunVsVal() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/overloadedFunVsVal.kt"); + } + + @Test + @TestMetadata("privateClassMember.kt") + public void testPrivateClassMember() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/privateClassMember.kt"); + } + + @Test + @TestMetadata("referenceToCompanionMember.kt") + public void testReferenceToCompanionMember() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/referenceToCompanionMember.kt"); + } + + @Test + @TestMetadata("sortListOfStrings.kt") + public void testSortListOfStrings() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/sortListOfStrings.kt"); + } + + @Test + @TestMetadata("specialCalls.kt") + public void testSpecialCalls() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/specialCalls.kt"); + } + + @Test + @TestMetadata("topLevelFromClass.kt") + public void testTopLevelFromClass() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/topLevelFromClass.kt"); + } + + @Test + @TestMetadata("topLevelFromExtension.kt") + public void testTopLevelFromExtension() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/topLevelFromExtension.kt"); + } + + @Test + @TestMetadata("topLevelFromTopLevelStringNoArgs.kt") + public void testTopLevelFromTopLevelStringNoArgs() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/topLevelFromTopLevelStringNoArgs.kt"); + } + + @Test + @TestMetadata("topLevelFromTopLevelStringOneStringArg.kt") + public void testTopLevelFromTopLevelStringOneStringArg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/topLevelFromTopLevelStringOneStringArg.kt"); + } + + @Test + @TestMetadata("topLevelFromTopLevelUnitManyArgs.kt") + public void testTopLevelFromTopLevelUnitManyArgs() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/topLevelFromTopLevelUnitManyArgs.kt"); + } + + @Test + @TestMetadata("topLevelFromTopLevelUnitNoArgs.kt") + public void testTopLevelFromTopLevelUnitNoArgs() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/topLevelFromTopLevelUnitNoArgs.kt"); + } + + @Test + @TestMetadata("topLevelFromTopLevelUnitOneStringArg.kt") + public void testTopLevelFromTopLevelUnitOneStringArg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/topLevelFromTopLevelUnitOneStringArg.kt"); + } + + @Test + @TestMetadata("traitImplMethodWithClassReceiver.kt") + public void testTraitImplMethodWithClassReceiver() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/traitImplMethodWithClassReceiver.kt"); + } + + @Test + @TestMetadata("traitMember.kt") + public void testTraitMember() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/traitMember.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/callableReference/function/local") + @TestDataPath("$PROJECT_ROOT") + public class Local { + @Test + public void testAllFilesPresentInLocal() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/function/local"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("captureOuter.kt") + public void testCaptureOuter() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/local/captureOuter.kt"); + } + + @Test + @TestMetadata("classMember.kt") + public void testClassMember() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/local/classMember.kt"); + } + + @Test + @TestMetadata("closureWithSideEffect.kt") + public void testClosureWithSideEffect() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/local/closureWithSideEffect.kt"); + } + + @Test + @TestMetadata("constructor.kt") + public void testConstructor() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/local/constructor.kt"); + } + + @Test + @TestMetadata("constructorWithInitializer.kt") + public void testConstructorWithInitializer() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/local/constructorWithInitializer.kt"); + } + + @Test + @TestMetadata("enumExtendsTrait.kt") + public void testEnumExtendsTrait() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/local/enumExtendsTrait.kt"); + } + + @Test + @TestMetadata("equalsHashCode.kt") + public void testEqualsHashCode() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/local/equalsHashCode.kt"); + } + + @Test + @TestMetadata("extension.kt") + public void testExtension() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/local/extension.kt"); + } + + @Test + @TestMetadata("extensionToLocalClass.kt") + public void testExtensionToLocalClass() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/local/extensionToLocalClass.kt"); + } + + @Test + @TestMetadata("extensionToPrimitive.kt") + public void testExtensionToPrimitive() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/local/extensionToPrimitive.kt"); + } + + @Test + @TestMetadata("extensionWithClosure.kt") + public void testExtensionWithClosure() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/local/extensionWithClosure.kt"); + } + + @Test + @TestMetadata("genericMember.kt") + public void testGenericMember() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/local/genericMember.kt"); + } + + @Test + @TestMetadata("localClassMember.kt") + public void testLocalClassMember() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/local/localClassMember.kt"); + } + + @Test + @TestMetadata("localFunctionName.kt") + public void testLocalFunctionName() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/local/localFunctionName.kt"); + } + + @Test + @TestMetadata("localLocal.kt") + public void testLocalLocal() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/local/localLocal.kt"); + } + + @Test + @TestMetadata("recursiveClosure.kt") + public void testRecursiveClosure() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/local/recursiveClosure.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/local/simple.kt"); + } + + @Test + @TestMetadata("simpleClosure.kt") + public void testSimpleClosure() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/local/simpleClosure.kt"); + } + + @Test + @TestMetadata("simpleWithArg.kt") + public void testSimpleWithArg() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/local/simpleWithArg.kt"); + } + + @Test + @TestMetadata("unitWithSideEffect.kt") + public void testUnitWithSideEffect() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/function/local/unitWithSideEffect.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/callableReference/property") + @TestDataPath("$PROJECT_ROOT") + public class Property { + @Test + @TestMetadata("accessViaSubclass.kt") + public void testAccessViaSubclass() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/accessViaSubclass.kt"); + } + + @Test + @TestMetadata("accessorForPropertyWithPrivateSetter.kt") + public void testAccessorForPropertyWithPrivateSetter() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/accessorForPropertyWithPrivateSetter.kt"); + } + + @Test + public void testAllFilesPresentInProperty() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/property"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("delegated.kt") + public void testDelegated() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/delegated.kt"); + } + + @Test + @TestMetadata("delegatedMutable.kt") + public void testDelegatedMutable() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/delegatedMutable.kt"); + } + + @Test + @TestMetadata("enumNameOrdinal.kt") + public void testEnumNameOrdinal() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/enumNameOrdinal.kt"); + } + + @Test + @TestMetadata("extensionToArray.kt") + public void testExtensionToArray() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/extensionToArray.kt"); + } + + @Test + @TestMetadata("genericProperty.kt") + public void testGenericProperty() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/genericProperty.kt"); + } + + @Test + @TestMetadata("inEnum.kt") + public void testInEnum() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/inEnum.kt"); + } + + @Test + @TestMetadata("inReceiverOfAnother.kt") + public void testInReceiverOfAnother() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/inReceiverOfAnother.kt"); + } + + @Test + @TestMetadata("invokePropertyReference.kt") + public void testInvokePropertyReference() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/invokePropertyReference.kt"); + } + + @Test + @TestMetadata("javaBeanConvention.kt") + public void testJavaBeanConvention() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/javaBeanConvention.kt"); + } + + @Test + @TestMetadata("kClassInstanceIsInitializedFirst.kt") + public void testKClassInstanceIsInitializedFirst() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/kClassInstanceIsInitializedFirst.kt"); + } + + @Test + @TestMetadata("kt12044.kt") + public void testKt12044() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/kt12044.kt"); + } + + @Test + @TestMetadata("kt12982_protectedPropertyReference.kt") + public void testKt12982_protectedPropertyReference() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/kt12982_protectedPropertyReference.kt"); + } + + @Test + @TestMetadata("kt14330.kt") + public void testKt14330() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/kt14330.kt"); + } + + @Test + @TestMetadata("kt14330_2.kt") + public void testKt14330_2() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/kt14330_2.kt"); + } + + @Test + @TestMetadata("kt15447.kt") + public void testKt15447() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/kt15447.kt"); + } + + @Test + @TestMetadata("listOfStringsMapLength.kt") + public void testListOfStringsMapLength() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/listOfStringsMapLength.kt"); + } + + @Test + @TestMetadata("localClassVar.kt") + public void testLocalClassVar() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/localClassVar.kt"); + } + + @Test + @TestMetadata("overriddenInSubclass.kt") + public void testOverriddenInSubclass() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/overriddenInSubclass.kt"); + } + + @Test + @TestMetadata("privateSetOuterClass.kt") + public void testPrivateSetOuterClass() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/privateSetOuterClass.kt"); + } + + @Test + @TestMetadata("privateSetterInsideClass.kt") + public void testPrivateSetterInsideClass() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/privateSetterInsideClass.kt"); + } + + @Test + @TestMetadata("privateSetterOutsideClass.kt") + public void testPrivateSetterOutsideClass() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/privateSetterOutsideClass.kt"); + } + + @Test + @TestMetadata("receiverEvaluatedOnce.kt") + public void testReceiverEvaluatedOnce() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/receiverEvaluatedOnce.kt"); + } + + @Test + @TestMetadata("simpleExtension.kt") + public void testSimpleExtension() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/simpleExtension.kt"); + } + + @Test + @TestMetadata("simpleMember.kt") + public void testSimpleMember() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/simpleMember.kt"); + } + + @Test + @TestMetadata("simpleMutableExtension.kt") + public void testSimpleMutableExtension() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/simpleMutableExtension.kt"); + } + + @Test + @TestMetadata("simpleMutableMember.kt") + public void testSimpleMutableMember() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/simpleMutableMember.kt"); + } + + @Test + @TestMetadata("simpleMutableTopLevel.kt") + public void testSimpleMutableTopLevel() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/simpleMutableTopLevel.kt"); + } + + @Test + @TestMetadata("simpleTopLevel.kt") + public void testSimpleTopLevel() throws Exception { + runTest("compiler/testData/codegen/box/callableReference/property/simpleTopLevel.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/callableReference/serializability") + @TestDataPath("$PROJECT_ROOT") + public class Serializability { + @Test + public void testAllFilesPresentInSerializability() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/callableReference/serializability"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/casts") + @TestDataPath("$PROJECT_ROOT") + public class Casts { + @Test + public void testAllFilesPresentInCasts() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("asForConstants.kt") + public void testAsForConstants() throws Exception { + runTest("compiler/testData/codegen/box/casts/asForConstants.kt"); + } + + @Test + @TestMetadata("asSafeFail.kt") + public void testAsSafeFail() throws Exception { + runTest("compiler/testData/codegen/box/casts/asSafeFail.kt"); + } + + @Test + @TestMetadata("asSafeForConstants.kt") + public void testAsSafeForConstants() throws Exception { + runTest("compiler/testData/codegen/box/casts/asSafeForConstants.kt"); + } + + @Test + @TestMetadata("asUnit.kt") + public void testAsUnit() throws Exception { + runTest("compiler/testData/codegen/box/casts/asUnit.kt"); + } + + @Test + @TestMetadata("asWithGeneric.kt") + public void testAsWithGeneric() throws Exception { + runTest("compiler/testData/codegen/box/casts/asWithGeneric.kt"); + } + + @Test + @TestMetadata("castGenericNull.kt") + public void testCastGenericNull() throws Exception { + runTest("compiler/testData/codegen/box/casts/castGenericNull.kt"); + } + + @Test + @TestMetadata("castToDefinitelyNotNullType.kt") + public void testCastToDefinitelyNotNullType() throws Exception { + runTest("compiler/testData/codegen/box/casts/castToDefinitelyNotNullType.kt"); + } + + @Test + @TestMetadata("dontCreateInconsistentTypeDuringStarProjectionSubstitution.kt") + public void testDontCreateInconsistentTypeDuringStarProjectionSubstitution() throws Exception { + runTest("compiler/testData/codegen/box/casts/dontCreateInconsistentTypeDuringStarProjectionSubstitution.kt"); + } + + @Test + @TestMetadata("genericReturnCast.kt") + public void testGenericReturnCast() throws Exception { + runTest("compiler/testData/codegen/box/casts/genericReturnCast.kt"); + } + + @Test + @TestMetadata("intersectionTypeMultipleBounds.kt") + public void testIntersectionTypeMultipleBounds() throws Exception { + runTest("compiler/testData/codegen/box/casts/intersectionTypeMultipleBounds.kt"); + } + + @Test + @TestMetadata("intersectionTypeMultipleBoundsImplicitReceiver.kt") + public void testIntersectionTypeMultipleBoundsImplicitReceiver() throws Exception { + runTest("compiler/testData/codegen/box/casts/intersectionTypeMultipleBoundsImplicitReceiver.kt"); + } + + @Test + @TestMetadata("intersectionTypeSmartcast.kt") + public void testIntersectionTypeSmartcast() throws Exception { + runTest("compiler/testData/codegen/box/casts/intersectionTypeSmartcast.kt"); + } + + @Test + @TestMetadata("intersectionTypeWithMultipleBoundsAsReceiver.kt") + public void testIntersectionTypeWithMultipleBoundsAsReceiver() throws Exception { + runTest("compiler/testData/codegen/box/casts/intersectionTypeWithMultipleBoundsAsReceiver.kt"); + } + + @Test + @TestMetadata("intersectionTypeWithoutGenericsAsReceiver.kt") + public void testIntersectionTypeWithoutGenericsAsReceiver() throws Exception { + runTest("compiler/testData/codegen/box/casts/intersectionTypeWithoutGenericsAsReceiver.kt"); + } + + @Test + @TestMetadata("isNullablePrimitive.kt") + public void testIsNullablePrimitive() throws Exception { + runTest("compiler/testData/codegen/box/casts/isNullablePrimitive.kt"); + } + + @Test + @TestMetadata("kt22714.kt") + public void testKt22714() throws Exception { + runTest("compiler/testData/codegen/box/casts/kt22714.kt"); + } + + @Test + @TestMetadata("kt48927_privateMethodOnDerivedCastToBase.kt") + public void testKt48927_privateMethodOnDerivedCastToBase() throws Exception { + runTest("compiler/testData/codegen/box/casts/kt48927_privateMethodOnDerivedCastToBase.kt"); + } + + @Test + @TestMetadata("kt50577.kt") + public void testKt50577() throws Exception { + runTest("compiler/testData/codegen/box/casts/kt50577.kt"); + } + + @Test + @TestMetadata("kt53677.kt") + public void testKt53677() throws Exception { + runTest("compiler/testData/codegen/box/casts/kt53677.kt"); + } + + @Test + @TestMetadata("kt54707.kt") + public void testKt54707() throws Exception { + runTest("compiler/testData/codegen/box/casts/kt54707.kt"); + } + + @Test + @TestMetadata("kt54802.kt") + public void testKt54802() throws Exception { + runTest("compiler/testData/codegen/box/casts/kt54802.kt"); + } + + @Test + @TestMetadata("kt58707.kt") + public void testKt58707() throws Exception { + runTest("compiler/testData/codegen/box/casts/kt58707.kt"); + } + + @Test + @TestMetadata("kt59022.kt") + public void testKt59022() throws Exception { + runTest("compiler/testData/codegen/box/casts/kt59022.kt"); + } + + @Test + @TestMetadata("lambdaToUnitCast.kt") + public void testLambdaToUnitCast() throws Exception { + runTest("compiler/testData/codegen/box/casts/lambdaToUnitCast.kt"); + } + + @Test + @TestMetadata("nullableSafeCastToTypeParameterWithInterfaceUpperBound.kt") + public void testNullableSafeCastToTypeParameterWithInterfaceUpperBound() throws Exception { + runTest("compiler/testData/codegen/box/casts/nullableSafeCastToTypeParameterWithInterfaceUpperBound.kt"); + } + + @Test + @TestMetadata("objectToPrimitiveWithAssertion.kt") + public void testObjectToPrimitiveWithAssertion() throws Exception { + runTest("compiler/testData/codegen/box/casts/objectToPrimitiveWithAssertion.kt"); + } + + @Test + @TestMetadata("unitAsAny.kt") + public void testUnitAsAny() throws Exception { + runTest("compiler/testData/codegen/box/casts/unitAsAny.kt"); + } + + @Test + @TestMetadata("unitAsSafeAny.kt") + public void testUnitAsSafeAny() throws Exception { + runTest("compiler/testData/codegen/box/casts/unitAsSafeAny.kt"); + } + + @Test + @TestMetadata("unitNullableCast.kt") + public void testUnitNullableCast() throws Exception { + runTest("compiler/testData/codegen/box/casts/unitNullableCast.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/casts/functions") + @TestDataPath("$PROJECT_ROOT") + public class Functions { + @Test + public void testAllFilesPresentInFunctions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/functions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("asFunKBig.kt") + public void testAsFunKBig() throws Exception { + runTest("compiler/testData/codegen/box/casts/functions/asFunKBig.kt"); + } + + @Test + @TestMetadata("asFunKSmall.kt") + public void testAsFunKSmall() throws Exception { + runTest("compiler/testData/codegen/box/casts/functions/asFunKSmall.kt"); + } + + @Test + @TestMetadata("isFunKBig.kt") + public void testIsFunKBig() throws Exception { + runTest("compiler/testData/codegen/box/casts/functions/isFunKBig.kt"); + } + + @Test + @TestMetadata("isFunKSmall.kt") + public void testIsFunKSmall() throws Exception { + runTest("compiler/testData/codegen/box/casts/functions/isFunKSmall.kt"); + } + + @Test + @TestMetadata("isFunKSmallNonJS.kt") + public void testIsFunKSmallNonJS() throws Exception { + runTest("compiler/testData/codegen/box/casts/functions/isFunKSmallNonJS.kt"); + } + + @Test + @TestMetadata("reifiedAsFunKBig.kt") + public void testReifiedAsFunKBig() throws Exception { + runTest("compiler/testData/codegen/box/casts/functions/reifiedAsFunKBig.kt"); + } + + @Test + @TestMetadata("reifiedAsFunKSmall.kt") + public void testReifiedAsFunKSmall() throws Exception { + runTest("compiler/testData/codegen/box/casts/functions/reifiedAsFunKSmall.kt"); + } + + @Test + @TestMetadata("reifiedIsFunKBig.kt") + public void testReifiedIsFunKBig() throws Exception { + runTest("compiler/testData/codegen/box/casts/functions/reifiedIsFunKBig.kt"); + } + + @Test + @TestMetadata("reifiedIsFunKSmall.kt") + public void testReifiedIsFunKSmall() throws Exception { + runTest("compiler/testData/codegen/box/casts/functions/reifiedIsFunKSmall.kt"); + } + + @Test + @TestMetadata("reifiedSafeAsFunKBig.kt") + public void testReifiedSafeAsFunKBig() throws Exception { + runTest("compiler/testData/codegen/box/casts/functions/reifiedSafeAsFunKBig.kt"); + } + + @Test + @TestMetadata("reifiedSafeAsFunKSmall.kt") + public void testReifiedSafeAsFunKSmall() throws Exception { + runTest("compiler/testData/codegen/box/casts/functions/reifiedSafeAsFunKSmall.kt"); + } + + @Test + @TestMetadata("safeAsFunKBig.kt") + public void testSafeAsFunKBig() throws Exception { + runTest("compiler/testData/codegen/box/casts/functions/safeAsFunKBig.kt"); + } + + @Test + @TestMetadata("safeAsFunKSmall.kt") + public void testSafeAsFunKSmall() throws Exception { + runTest("compiler/testData/codegen/box/casts/functions/safeAsFunKSmall.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/casts/javaInterop") + @TestDataPath("$PROJECT_ROOT") + public class JavaInterop { + @Test + public void testAllFilesPresentInJavaInterop() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/javaInterop"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument") + @TestDataPath("$PROJECT_ROOT") + public class LiteralExpressionAsGenericArgument { + @Test + public void testAllFilesPresentInLiteralExpressionAsGenericArgument() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("binaryExpressionCast.kt") + public void testBinaryExpressionCast() throws Exception { + runTest("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument/binaryExpressionCast.kt"); + } + + @Test + @TestMetadata("labeledExpressionCast.kt") + public void testLabeledExpressionCast() throws Exception { + runTest("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument/labeledExpressionCast.kt"); + } + + @Test + @TestMetadata("parenthesizedExpressionCast.kt") + public void testParenthesizedExpressionCast() throws Exception { + runTest("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument/parenthesizedExpressionCast.kt"); + } + + @Test + @TestMetadata("superConstructor.kt") + public void testSuperConstructor() throws Exception { + runTest("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument/superConstructor.kt"); + } + + @Test + @TestMetadata("unaryExpressionCast.kt") + public void testUnaryExpressionCast() throws Exception { + runTest("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument/unaryExpressionCast.kt"); + } + + @Test + @TestMetadata("vararg.kt") + public void testVararg() throws Exception { + runTest("compiler/testData/codegen/box/casts/literalExpressionAsGenericArgument/vararg.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/casts/mutableCollections") + @TestDataPath("$PROJECT_ROOT") + public class MutableCollections { + @Test + public void testAllFilesPresentInMutableCollections() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/mutableCollections"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("asWithMutable.kt") + public void testAsWithMutable() throws Exception { + runTest("compiler/testData/codegen/box/casts/mutableCollections/asWithMutable.kt"); + } + + @Test + @TestMetadata("isWithMutable.kt") + public void testIsWithMutable() throws Exception { + runTest("compiler/testData/codegen/box/casts/mutableCollections/isWithMutable.kt"); + } + + @Test + @TestMetadata("reifiedAsWithMutable.kt") + public void testReifiedAsWithMutable() throws Exception { + runTest("compiler/testData/codegen/box/casts/mutableCollections/reifiedAsWithMutable.kt"); + } + + @Test + @TestMetadata("reifiedIsWithMutable.kt") + public void testReifiedIsWithMutable() throws Exception { + runTest("compiler/testData/codegen/box/casts/mutableCollections/reifiedIsWithMutable.kt"); + } + + @Test + @TestMetadata("reifiedSafeAsWithMutable.kt") + public void testReifiedSafeAsWithMutable() throws Exception { + runTest("compiler/testData/codegen/box/casts/mutableCollections/reifiedSafeAsWithMutable.kt"); + } + + @Test + @TestMetadata("safeAsWithMutable.kt") + public void testSafeAsWithMutable() throws Exception { + runTest("compiler/testData/codegen/box/casts/mutableCollections/safeAsWithMutable.kt"); + } + + @Test + @TestMetadata("weirdMutableCasts.kt") + public void testWeirdMutableCasts() throws Exception { + runTest("compiler/testData/codegen/box/casts/mutableCollections/weirdMutableCasts.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/casts/nativeCCEMessage") + @TestDataPath("$PROJECT_ROOT") + public class NativeCCEMessage { + @Test + public void testAllFilesPresentInNativeCCEMessage() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/casts/nativeCCEMessage"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/checkcastOptimization") + @TestDataPath("$PROJECT_ROOT") + public class CheckcastOptimization { + @Test + public void testAllFilesPresentInCheckcastOptimization() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/checkcastOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt19128.kt") + public void testKt19128() throws Exception { + runTest("compiler/testData/codegen/box/checkcastOptimization/kt19128.kt"); + } + + @Test + @TestMetadata("kt19246.kt") + public void testKt19246() throws Exception { + runTest("compiler/testData/codegen/box/checkcastOptimization/kt19246.kt"); + } + + @Test + @TestMetadata("kt47851.kt") + public void testKt47851() throws Exception { + runTest("compiler/testData/codegen/box/checkcastOptimization/kt47851.kt"); + } + + @Test + @TestMetadata("kt50215.kt") + public void testKt50215() throws Exception { + runTest("compiler/testData/codegen/box/checkcastOptimization/kt50215.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/classLiteral") + @TestDataPath("$PROJECT_ROOT") + public class ClassLiteral { + @Test + public void testAllFilesPresentInClassLiteral() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("bareArray.kt") + public void testBareArray() throws Exception { + runTest("compiler/testData/codegen/box/classLiteral/bareArray.kt"); + } + + @Test + @TestMetadata("classEquality.kt") + public void testClassEquality() throws Exception { + runTest("compiler/testData/codegen/box/classLiteral/classEquality.kt"); + } + + @Test + @TestMetadata("primitiveClassEquality.kt") + public void testPrimitiveClassEquality() throws Exception { + runTest("compiler/testData/codegen/box/classLiteral/primitiveClassEquality.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/classLiteral/bound") + @TestDataPath("$PROJECT_ROOT") + public class Bound { + @Test + public void testAllFilesPresentInBound() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/bound"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("primitives.kt") + public void testPrimitives() throws Exception { + runTest("compiler/testData/codegen/box/classLiteral/bound/primitives.kt"); + } + + @Test + @TestMetadata("sideEffect.kt") + public void testSideEffect() throws Exception { + runTest("compiler/testData/codegen/box/classLiteral/bound/sideEffect.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/classLiteral/bound/simple.kt"); + } + + @Test + @TestMetadata("smartCast.kt") + public void testSmartCast() throws Exception { + runTest("compiler/testData/codegen/box/classLiteral/bound/smartCast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/classLiteral/java") + @TestDataPath("$PROJECT_ROOT") + public class Java { + @Test + public void testAllFilesPresentInJava() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classLiteral/java"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/classes") + @TestDataPath("$PROJECT_ROOT") + public class Classes { + @Test + public void testAllFilesPresentInClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("boxPrimitiveTypeInClinitOfClassObject.kt") + public void testBoxPrimitiveTypeInClinitOfClassObject() throws Exception { + runTest("compiler/testData/codegen/box/classes/boxPrimitiveTypeInClinitOfClassObject.kt"); + } + + @Test + @TestMetadata("classNamedAsOldPackageFacade.kt") + public void testClassNamedAsOldPackageFacade() throws Exception { + runTest("compiler/testData/codegen/box/classes/classNamedAsOldPackageFacade.kt"); + } + + @Test + @TestMetadata("classObject.kt") + public void testClassObject() throws Exception { + runTest("compiler/testData/codegen/box/classes/classObject.kt"); + } + + @Test + @TestMetadata("classObjectAsExtensionReceiver.kt") + public void testClassObjectAsExtensionReceiver() throws Exception { + runTest("compiler/testData/codegen/box/classes/classObjectAsExtensionReceiver.kt"); + } + + @Test + @TestMetadata("classObjectAsStaticInitializer.kt") + public void testClassObjectAsStaticInitializer() throws Exception { + runTest("compiler/testData/codegen/box/classes/classObjectAsStaticInitializer.kt"); + } + + @Test + @TestMetadata("classObjectField.kt") + public void testClassObjectField() throws Exception { + runTest("compiler/testData/codegen/box/classes/classObjectField.kt"); + } + + @Test + @TestMetadata("classObjectInTrait.kt") + public void testClassObjectInTrait() throws Exception { + runTest("compiler/testData/codegen/box/classes/classObjectInTrait.kt"); + } + + @Test + @TestMetadata("classObjectNotOfEnum.kt") + public void testClassObjectNotOfEnum() throws Exception { + runTest("compiler/testData/codegen/box/classes/classObjectNotOfEnum.kt"); + } + + @Test + @TestMetadata("classObjectWithPrivateGenericMember.kt") + public void testClassObjectWithPrivateGenericMember() throws Exception { + runTest("compiler/testData/codegen/box/classes/classObjectWithPrivateGenericMember.kt"); + } + + @Test + @TestMetadata("classObjectsWithParentClasses.kt") + public void testClassObjectsWithParentClasses() throws Exception { + runTest("compiler/testData/codegen/box/classes/classObjectsWithParentClasses.kt"); + } + + @Test + @TestMetadata("comanionObjectFieldVsClassField.kt") + public void testComanionObjectFieldVsClassField() throws Exception { + runTest("compiler/testData/codegen/box/classes/comanionObjectFieldVsClassField.kt"); + } + + @Test + @TestMetadata("defaultObjectSameNamesAsInOuter.kt") + public void testDefaultObjectSameNamesAsInOuter() throws Exception { + runTest("compiler/testData/codegen/box/classes/defaultObjectSameNamesAsInOuter.kt"); + } + + @Test + @TestMetadata("delegateConstructorCallWithKeywords.kt") + public void testDelegateConstructorCallWithKeywords() throws Exception { + runTest("compiler/testData/codegen/box/classes/delegateConstructorCallWithKeywords.kt"); + } + + @Test + @TestMetadata("delegation2.kt") + public void testDelegation2() throws Exception { + runTest("compiler/testData/codegen/box/classes/delegation2.kt"); + } + + @Test + @TestMetadata("delegation3.kt") + public void testDelegation3() throws Exception { + runTest("compiler/testData/codegen/box/classes/delegation3.kt"); + } + + @Test + @TestMetadata("delegation4.kt") + public void testDelegation4() throws Exception { + runTest("compiler/testData/codegen/box/classes/delegation4.kt"); + } + + @Test + @TestMetadata("delegationGenericArg.kt") + public void testDelegationGenericArg() throws Exception { + runTest("compiler/testData/codegen/box/classes/delegationGenericArg.kt"); + } + + @Test + @TestMetadata("delegationGenericArgUpperBound.kt") + public void testDelegationGenericArgUpperBound() throws Exception { + runTest("compiler/testData/codegen/box/classes/delegationGenericArgUpperBound.kt"); + } + + @Test + @TestMetadata("delegationGenericLongArg.kt") + public void testDelegationGenericLongArg() throws Exception { + runTest("compiler/testData/codegen/box/classes/delegationGenericLongArg.kt"); + } + + @Test + @TestMetadata("delegationMethodsWithArgs.kt") + public void testDelegationMethodsWithArgs() throws Exception { + runTest("compiler/testData/codegen/box/classes/delegationMethodsWithArgs.kt"); + } + + @Test + @TestMetadata("exceptionConstructor.kt") + public void testExceptionConstructor() throws Exception { + runTest("compiler/testData/codegen/box/classes/exceptionConstructor.kt"); + } + + @Test + @TestMetadata("extensionFunWithDefaultParam.kt") + public void testExtensionFunWithDefaultParam() throws Exception { + runTest("compiler/testData/codegen/box/classes/extensionFunWithDefaultParam.kt"); + } + + @Test + @TestMetadata("extensionOnNamedClassObject.kt") + public void testExtensionOnNamedClassObject() throws Exception { + runTest("compiler/testData/codegen/box/classes/extensionOnNamedClassObject.kt"); + } + + @Test + @TestMetadata("funDelegation.kt") + public void testFunDelegation() throws Exception { + runTest("compiler/testData/codegen/box/classes/funDelegation.kt"); + } + + @Test + @TestMetadata("implementComparableInSubclass.kt") + public void testImplementComparableInSubclass() throws Exception { + runTest("compiler/testData/codegen/box/classes/implementComparableInSubclass.kt"); + } + + @Test + @TestMetadata("inheritSetAndHashSet.kt") + public void testInheritSetAndHashSet() throws Exception { + runTest("compiler/testData/codegen/box/classes/inheritSetAndHashSet.kt"); + } + + @Test + @TestMetadata("inheritance.kt") + public void testInheritance() throws Exception { + runTest("compiler/testData/codegen/box/classes/inheritance.kt"); + } + + @Test + @TestMetadata("inheritedInnerClass.kt") + public void testInheritedInnerClass() throws Exception { + runTest("compiler/testData/codegen/box/classes/inheritedInnerClass.kt"); + } + + @Test + @TestMetadata("inheritedMethod.kt") + public void testInheritedMethod() throws Exception { + runTest("compiler/testData/codegen/box/classes/inheritedMethod.kt"); + } + + @Test + @TestMetadata("initializerBlock.kt") + public void testInitializerBlock() throws Exception { + runTest("compiler/testData/codegen/box/classes/initializerBlock.kt"); + } + + @Test + @TestMetadata("initializerBlockDImpl.kt") + public void testInitializerBlockDImpl() throws Exception { + runTest("compiler/testData/codegen/box/classes/initializerBlockDImpl.kt"); + } + + @Test + @TestMetadata("initializerBlockResetToDefault.kt") + public void testInitializerBlockResetToDefault() throws Exception { + runTest("compiler/testData/codegen/box/classes/initializerBlockResetToDefault.kt"); + } + + @Test + @TestMetadata("innerClass.kt") + public void testInnerClass() throws Exception { + runTest("compiler/testData/codegen/box/classes/innerClass.kt"); + } + + @Test + @TestMetadata("kt1018.kt") + public void testKt1018() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt1018.kt"); + } + + @Test + @TestMetadata("kt1157.kt") + public void testKt1157() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt1157.kt"); + } + + @Test + @TestMetadata("kt1247.kt") + public void testKt1247() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt1247.kt"); + } + + @Test + @TestMetadata("kt1345.kt") + public void testKt1345() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt1345.kt"); + } + + @Test + @TestMetadata("kt1439.kt") + public void testKt1439() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt1439.kt"); + } + + @Test + @TestMetadata("kt1535.kt") + public void testKt1535() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt1535.kt"); + } + + @Test + @TestMetadata("kt1538.kt") + public void testKt1538() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt1538.kt"); + } + + @Test + @TestMetadata("kt1578.kt") + public void testKt1578() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt1578.kt"); + } + + @Test + @TestMetadata("kt1611.kt") + public void testKt1611() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt1611.kt"); + } + + @Test + @TestMetadata("kt1721.kt") + public void testKt1721() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt1721.kt"); + } + + @Test + @TestMetadata("kt1726.kt") + public void testKt1726() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt1726.kt"); + } + + @Test + @TestMetadata("kt1759.kt") + public void testKt1759() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt1759.kt"); + } + + @Test + @TestMetadata("kt1891.kt") + public void testKt1891() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt1891.kt"); + } + + @Test + @TestMetadata("kt1918.kt") + public void testKt1918() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt1918.kt"); + } + + @Test + @TestMetadata("kt1976.kt") + public void testKt1976() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt1976.kt"); + } + + @Test + @TestMetadata("kt1980.kt") + public void testKt1980() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt1980.kt"); + } + + @Test + @TestMetadata("kt2224.kt") + public void testKt2224() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt2224.kt"); + } + + @Test + @TestMetadata("kt2384.kt") + public void testKt2384() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt2384.kt"); + } + + @Test + @TestMetadata("kt2390.kt") + public void testKt2390() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt2390.kt"); + } + + @Test + @TestMetadata("kt2391.kt") + public void testKt2391() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt2391.kt"); + } + + @Test + @TestMetadata("kt2417.kt") + public void testKt2417() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt2417.kt"); + } + + @Test + @TestMetadata("kt2477.kt") + public void testKt2477() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt2477.kt"); + } + + @Test + @TestMetadata("kt2480.kt") + public void testKt2480() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt2480.kt"); + } + + @Test + @TestMetadata("kt2482.kt") + public void testKt2482() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt2482.kt"); + } + + @Test + @TestMetadata("kt2485.kt") + public void testKt2485() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt2485.kt"); + } + + @Test + @TestMetadata("kt249.kt") + public void testKt249() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt249.kt"); + } + + @Test + @TestMetadata("kt2532.kt") + public void testKt2532() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt2532.kt"); + } + + @Test + @TestMetadata("kt2566.kt") + public void testKt2566() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt2566.kt"); + } + + @Test + @TestMetadata("kt2566_2.kt") + public void testKt2566_2() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt2566_2.kt"); + } + + @Test + @TestMetadata("kt2607.kt") + public void testKt2607() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt2607.kt"); + } + + @Test + @TestMetadata("kt2626.kt") + public void testKt2626() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt2626.kt"); + } + + @Test + @TestMetadata("kt2711.kt") + public void testKt2711() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt2711.kt"); + } + + @Test + @TestMetadata("kt2784.kt") + public void testKt2784() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt2784.kt"); + } + + @Test + @TestMetadata("kt285.kt") + public void testKt285() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt285.kt"); + } + + @Test + @TestMetadata("kt3001.kt") + public void testKt3001() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt3001.kt"); + } + + @Test + @TestMetadata("kt3114.kt") + public void testKt3114() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt3114.kt"); + } + + @Test + @TestMetadata("kt3414.kt") + public void testKt3414() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt3414.kt"); + } + + @Test + @TestMetadata("kt343.kt") + public void testKt343() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt343.kt"); + } + + @Test + @TestMetadata("kt3546.kt") + public void testKt3546() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt3546.kt"); + } + + @Test + @TestMetadata("kt40332.kt") + public void testKt40332() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt40332.kt"); + } + + @Test + @TestMetadata("kt454.kt") + public void testKt454() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt454.kt"); + } + + @Test + @TestMetadata("kt471.kt") + public void testKt471() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt471.kt"); + } + + @Test + @TestMetadata("kt48.kt") + public void testKt48() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt48.kt"); + } + + @Test + @TestMetadata("kt496.kt") + public void testKt496() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt496.kt"); + } + + @Test + @TestMetadata("kt500.kt") + public void testKt500() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt500.kt"); + } + + @Test + @TestMetadata("kt501.kt") + public void testKt501() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt501.kt"); + } + + @Test + @TestMetadata("kt504.kt") + public void testKt504() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt504.kt"); + } + + @Test + @TestMetadata("kt508.kt") + public void testKt508() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt508.kt"); + } + + @Test + @TestMetadata("kt5347.kt") + public void testKt5347() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt5347.kt"); + } + + @Test + @TestMetadata("kt6136.kt") + public void testKt6136() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt6136.kt"); + } + + @Test + @TestMetadata("kt633.kt") + public void testKt633() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt633.kt"); + } + + @Test + @TestMetadata("kt6816.kt") + public void testKt6816() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt6816.kt"); + } + + @Test + @TestMetadata("kt707.kt") + public void testKt707() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt707.kt"); + } + + @Test + @TestMetadata("kt723.kt") + public void testKt723() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt723.kt"); + } + + @Test + @TestMetadata("kt725.kt") + public void testKt725() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt725.kt"); + } + + @Test + @TestMetadata("kt8011.kt") + public void testKt8011() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt8011.kt"); + } + + @Test + @TestMetadata("kt8011a.kt") + public void testKt8011a() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt8011a.kt"); + } + + @Test + @TestMetadata("kt940.kt") + public void testKt940() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt940.kt"); + } + + @Test + @TestMetadata("kt9642.kt") + public void testKt9642() throws Exception { + runTest("compiler/testData/codegen/box/classes/kt9642.kt"); + } + + @Test + @TestMetadata("namedClassObject.kt") + public void testNamedClassObject() throws Exception { + runTest("compiler/testData/codegen/box/classes/namedClassObject.kt"); + } + + @Test + @TestMetadata("outerThis.kt") + public void testOuterThis() throws Exception { + runTest("compiler/testData/codegen/box/classes/outerThis.kt"); + } + + @Test + @TestMetadata("overloadBinaryOperator.kt") + public void testOverloadBinaryOperator() throws Exception { + runTest("compiler/testData/codegen/box/classes/overloadBinaryOperator.kt"); + } + + @Test + @TestMetadata("overloadPlusAssign.kt") + public void testOverloadPlusAssign() throws Exception { + runTest("compiler/testData/codegen/box/classes/overloadPlusAssign.kt"); + } + + @Test + @TestMetadata("overloadPlusAssignReturn.kt") + public void testOverloadPlusAssignReturn() throws Exception { + runTest("compiler/testData/codegen/box/classes/overloadPlusAssignReturn.kt"); + } + + @Test + @TestMetadata("overloadPlusToPlusAssign.kt") + public void testOverloadPlusToPlusAssign() throws Exception { + runTest("compiler/testData/codegen/box/classes/overloadPlusToPlusAssign.kt"); + } + + @Test + @TestMetadata("overloadUnaryOperator.kt") + public void testOverloadUnaryOperator() throws Exception { + runTest("compiler/testData/codegen/box/classes/overloadUnaryOperator.kt"); + } + + @Test + @TestMetadata("privateOuterFunctions.kt") + public void testPrivateOuterFunctions() throws Exception { + runTest("compiler/testData/codegen/box/classes/privateOuterFunctions.kt"); + } + + @Test + @TestMetadata("privateOuterProperty.kt") + public void testPrivateOuterProperty() throws Exception { + runTest("compiler/testData/codegen/box/classes/privateOuterProperty.kt"); + } + + @Test + @TestMetadata("privateToThis.kt") + public void testPrivateToThis() throws Exception { + runTest("compiler/testData/codegen/box/classes/privateToThis.kt"); + } + + @Test + @TestMetadata("propertyDelegation.kt") + public void testPropertyDelegation() throws Exception { + runTest("compiler/testData/codegen/box/classes/propertyDelegation.kt"); + } + + @Test + @TestMetadata("propertyInInitializer.kt") + public void testPropertyInInitializer() throws Exception { + runTest("compiler/testData/codegen/box/classes/propertyInInitializer.kt"); + } + + @Test + @TestMetadata("quotedClassName.kt") + public void testQuotedClassName() throws Exception { + runTest("compiler/testData/codegen/box/classes/quotedClassName.kt"); + } + + @Test + @TestMetadata("rightHandOverride.kt") + public void testRightHandOverride() throws Exception { + runTest("compiler/testData/codegen/box/classes/rightHandOverride.kt"); + } + + @Test + @TestMetadata("selfcreate.kt") + public void testSelfcreate() throws Exception { + runTest("compiler/testData/codegen/box/classes/selfcreate.kt"); + } + + @Test + @TestMetadata("simpleBox.kt") + public void testSimpleBox() throws Exception { + runTest("compiler/testData/codegen/box/classes/simpleBox.kt"); + } + + @Test + @TestMetadata("superConstructorCallWithComplexArg.kt") + public void testSuperConstructorCallWithComplexArg() throws Exception { + runTest("compiler/testData/codegen/box/classes/superConstructorCallWithComplexArg.kt"); + } + + @Test + @TestMetadata("typedDelegation.kt") + public void testTypedDelegation() throws Exception { + runTest("compiler/testData/codegen/box/classes/typedDelegation.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/classes/inner") + @TestDataPath("$PROJECT_ROOT") + public class Inner { + @Test + public void testAllFilesPresentInInner() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/classes/inner"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("extensionWithOuter.kt") + public void testExtensionWithOuter() throws Exception { + runTest("compiler/testData/codegen/box/classes/inner/extensionWithOuter.kt"); + } + + @Test + @TestMetadata("instantiateInDerived.kt") + public void testInstantiateInDerived() throws Exception { + runTest("compiler/testData/codegen/box/classes/inner/instantiateInDerived.kt"); + } + + @Test + @TestMetadata("instantiateInDerivedLabeled.kt") + public void testInstantiateInDerivedLabeled() throws Exception { + runTest("compiler/testData/codegen/box/classes/inner/instantiateInDerivedLabeled.kt"); + } + + @Test + @TestMetadata("instantiateInSameClass.kt") + public void testInstantiateInSameClass() throws Exception { + runTest("compiler/testData/codegen/box/classes/inner/instantiateInSameClass.kt"); + } + + @Test + @TestMetadata("kt6708.kt") + public void testKt6708() throws Exception { + runTest("compiler/testData/codegen/box/classes/inner/kt6708.kt"); + } + + @Test + @TestMetadata("properOuter.kt") + public void testProperOuter() throws Exception { + runTest("compiler/testData/codegen/box/classes/inner/properOuter.kt"); + } + + @Test + @TestMetadata("properSuperLinking.kt") + public void testProperSuperLinking() throws Exception { + runTest("compiler/testData/codegen/box/classes/inner/properSuperLinking.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/closures") + @TestDataPath("$PROJECT_ROOT") + public class Closures { + @Test + public void testAllFilesPresentInClosures() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("anonymousObjectAsLastExpressionInLambda.kt") + public void testAnonymousObjectAsLastExpressionInLambda() throws Exception { + runTest("compiler/testData/codegen/box/closures/anonymousObjectAsLastExpressionInLambda.kt"); + } + + @Test + @TestMetadata("captureExtensionReceiver.kt") + public void testCaptureExtensionReceiver() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureExtensionReceiver.kt"); + } + + @Test + @TestMetadata("captureExtensionReceiverX2.kt") + public void testCaptureExtensionReceiverX2() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureExtensionReceiverX2.kt"); + } + + @Test + @TestMetadata("capturedLocalGenericFun.kt") + public void testCapturedLocalGenericFun() throws Exception { + runTest("compiler/testData/codegen/box/closures/capturedLocalGenericFun.kt"); + } + + @Test + @TestMetadata("closureCapturingGenericParam.kt") + public void testClosureCapturingGenericParam() throws Exception { + runTest("compiler/testData/codegen/box/closures/closureCapturingGenericParam.kt"); + } + + @Test + @TestMetadata("closureInsideConstrucor.kt") + public void testClosureInsideConstrucor() throws Exception { + runTest("compiler/testData/codegen/box/closures/closureInsideConstrucor.kt"); + } + + @Test + @TestMetadata("closureOnTopLevel1.kt") + public void testClosureOnTopLevel1() throws Exception { + runTest("compiler/testData/codegen/box/closures/closureOnTopLevel1.kt"); + } + + @Test + @TestMetadata("closureOnTopLevel2.kt") + public void testClosureOnTopLevel2() throws Exception { + runTest("compiler/testData/codegen/box/closures/closureOnTopLevel2.kt"); + } + + @Test + @TestMetadata("closureWithParameter.kt") + public void testClosureWithParameter() throws Exception { + runTest("compiler/testData/codegen/box/closures/closureWithParameter.kt"); + } + + @Test + @TestMetadata("closureWithParameterAndBoxing.kt") + public void testClosureWithParameterAndBoxing() throws Exception { + runTest("compiler/testData/codegen/box/closures/closureWithParameterAndBoxing.kt"); + } + + @Test + @TestMetadata("crossinlineLocalDeclaration.kt") + public void testCrossinlineLocalDeclaration() throws Exception { + runTest("compiler/testData/codegen/box/closures/crossinlineLocalDeclaration.kt"); + } + + @Test + @TestMetadata("doubleEnclosedLocalVariable.kt") + public void testDoubleEnclosedLocalVariable() throws Exception { + runTest("compiler/testData/codegen/box/closures/doubleEnclosedLocalVariable.kt"); + } + + @Test + @TestMetadata("enclosingLocalVariable.kt") + public void testEnclosingLocalVariable() throws Exception { + runTest("compiler/testData/codegen/box/closures/enclosingLocalVariable.kt"); + } + + @Test + @TestMetadata("enclosingThis.kt") + public void testEnclosingThis() throws Exception { + runTest("compiler/testData/codegen/box/closures/enclosingThis.kt"); + } + + @Test + @TestMetadata("extensionClosure.kt") + public void testExtensionClosure() throws Exception { + runTest("compiler/testData/codegen/box/closures/extensionClosure.kt"); + } + + @Test + @TestMetadata("kt10044.kt") + public void testKt10044() throws Exception { + runTest("compiler/testData/codegen/box/closures/kt10044.kt"); + } + + @Test + @TestMetadata("kt11634.kt") + public void testKt11634() throws Exception { + runTest("compiler/testData/codegen/box/closures/kt11634.kt"); + } + + @Test + @TestMetadata("kt11634_2.kt") + public void testKt11634_2() throws Exception { + runTest("compiler/testData/codegen/box/closures/kt11634_2.kt"); + } + + @Test + @TestMetadata("kt11634_3.kt") + public void testKt11634_3() throws Exception { + runTest("compiler/testData/codegen/box/closures/kt11634_3.kt"); + } + + @Test + @TestMetadata("kt11634_4.kt") + public void testKt11634_4() throws Exception { + runTest("compiler/testData/codegen/box/closures/kt11634_4.kt"); + } + + @Test + @TestMetadata("kt19389.kt") + public void testKt19389() throws Exception { + runTest("compiler/testData/codegen/box/closures/kt19389.kt"); + } + + @Test + @TestMetadata("kt19389_set.kt") + public void testKt19389_set() throws Exception { + runTest("compiler/testData/codegen/box/closures/kt19389_set.kt"); + } + + @Test + @TestMetadata("kt2151.kt") + public void testKt2151() throws Exception { + runTest("compiler/testData/codegen/box/closures/kt2151.kt"); + } + + @Test + @TestMetadata("kt3152.kt") + public void testKt3152() throws Exception { + runTest("compiler/testData/codegen/box/closures/kt3152.kt"); + } + + @Test + @TestMetadata("kt3523.kt") + public void testKt3523() throws Exception { + runTest("compiler/testData/codegen/box/closures/kt3523.kt"); + } + + @Test + @TestMetadata("kt3738.kt") + public void testKt3738() throws Exception { + runTest("compiler/testData/codegen/box/closures/kt3738.kt"); + } + + @Test + @TestMetadata("kt3905.kt") + public void testKt3905() throws Exception { + runTest("compiler/testData/codegen/box/closures/kt3905.kt"); + } + + @Test + @TestMetadata("kt4106.kt") + public void testKt4106() throws Exception { + runTest("compiler/testData/codegen/box/closures/kt4106.kt"); + } + + @Test + @TestMetadata("kt4137.kt") + public void testKt4137() throws Exception { + runTest("compiler/testData/codegen/box/closures/kt4137.kt"); + } + + @Test + @TestMetadata("kt47840.kt") + public void testKt47840() throws Exception { + runTest("compiler/testData/codegen/box/closures/kt47840.kt"); + } + + @Test + @TestMetadata("kt47894_inlineFunWithObjectWithNothing.kt") + public void testKt47894_inlineFunWithObjectWithNothing() throws Exception { + runTest("compiler/testData/codegen/box/closures/kt47894_inlineFunWithObjectWithNothing.kt"); + } + + @Test + @TestMetadata("kt5589.kt") + public void testKt5589() throws Exception { + runTest("compiler/testData/codegen/box/closures/kt5589.kt"); + } + + @Test + @TestMetadata("localClassFunClosure.kt") + public void testLocalClassFunClosure() throws Exception { + runTest("compiler/testData/codegen/box/closures/localClassFunClosure.kt"); + } + + @Test + @TestMetadata("localClassLambdaClosure.kt") + public void testLocalClassLambdaClosure() throws Exception { + runTest("compiler/testData/codegen/box/closures/localClassLambdaClosure.kt"); + } + + @Test + @TestMetadata("localFunInInit.kt") + public void testLocalFunInInit() throws Exception { + runTest("compiler/testData/codegen/box/closures/localFunInInit.kt"); + } + + @Test + @TestMetadata("localFunctionInFunction.kt") + public void testLocalFunctionInFunction() throws Exception { + runTest("compiler/testData/codegen/box/closures/localFunctionInFunction.kt"); + } + + @Test + @TestMetadata("localFunctionInInitBlock.kt") + public void testLocalFunctionInInitBlock() throws Exception { + runTest("compiler/testData/codegen/box/closures/localFunctionInInitBlock.kt"); + } + + @Test + @TestMetadata("localFunctionInInitializer.kt") + public void testLocalFunctionInInitializer() throws Exception { + runTest("compiler/testData/codegen/box/closures/localFunctionInInitializer.kt"); + } + + @Test + @TestMetadata("localGenericFun.kt") + public void testLocalGenericFun() throws Exception { + runTest("compiler/testData/codegen/box/closures/localGenericFun.kt"); + } + + @Test + @TestMetadata("localReturn.kt") + public void testLocalReturn() throws Exception { + runTest("compiler/testData/codegen/box/closures/localReturn.kt"); + } + + @Test + @TestMetadata("localReturnWithAutolabel.kt") + public void testLocalReturnWithAutolabel() throws Exception { + runTest("compiler/testData/codegen/box/closures/localReturnWithAutolabel.kt"); + } + + @Test + @TestMetadata("recursiveClosure.kt") + public void testRecursiveClosure() throws Exception { + runTest("compiler/testData/codegen/box/closures/recursiveClosure.kt"); + } + + @Test + @TestMetadata("simplestClosure.kt") + public void testSimplestClosure() throws Exception { + runTest("compiler/testData/codegen/box/closures/simplestClosure.kt"); + } + + @Test + @TestMetadata("simplestClosureAndBoxing.kt") + public void testSimplestClosureAndBoxing() throws Exception { + runTest("compiler/testData/codegen/box/closures/simplestClosureAndBoxing.kt"); + } + + @Test + @TestMetadata("subclosuresWithinInitializers.kt") + public void testSubclosuresWithinInitializers() throws Exception { + runTest("compiler/testData/codegen/box/closures/subclosuresWithinInitializers.kt"); + } + + @Test + @TestMetadata("underscoreParameters.kt") + public void testUnderscoreParameters() throws Exception { + runTest("compiler/testData/codegen/box/closures/underscoreParameters.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/closures/captureInSuperConstructorCall") + @TestDataPath("$PROJECT_ROOT") + public class CaptureInSuperConstructorCall { + @Test + public void testAllFilesPresentInCaptureInSuperConstructorCall() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureInSuperConstructorCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("constructorParameterAndLocalCapturedInLambdaInLocalClass.kt") + public void testConstructorParameterAndLocalCapturedInLambdaInLocalClass() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/constructorParameterAndLocalCapturedInLambdaInLocalClass.kt"); + } + + @Test + @TestMetadata("constructorParameterCapturedInLambdaInLocalClass.kt") + public void testConstructorParameterCapturedInLambdaInLocalClass() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/constructorParameterCapturedInLambdaInLocalClass.kt"); + } + + @Test + @TestMetadata("constructorParameterCapturedInLambdaInLocalClass2.kt") + public void testConstructorParameterCapturedInLambdaInLocalClass2() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/constructorParameterCapturedInLambdaInLocalClass2.kt"); + } + + @Test + @TestMetadata("kt13454.kt") + public void testKt13454() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/kt13454.kt"); + } + + @Test + @TestMetadata("kt14148.kt") + public void testKt14148() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/kt14148.kt"); + } + + @Test + @TestMetadata("kt4174.kt") + public void testKt4174() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/kt4174.kt"); + } + + @Test + @TestMetadata("kt4174a.kt") + public void testKt4174a() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/kt4174a.kt"); + } + + @Test + @TestMetadata("localCapturedInAnonymousObjectInLocalClass.kt") + public void testLocalCapturedInAnonymousObjectInLocalClass() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/localCapturedInAnonymousObjectInLocalClass.kt"); + } + + @Test + @TestMetadata("localCapturedInAnonymousObjectInLocalClass2.kt") + public void testLocalCapturedInAnonymousObjectInLocalClass2() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/localCapturedInAnonymousObjectInLocalClass2.kt"); + } + + @Test + @TestMetadata("localCapturedInLambdaInInnerClassInLocalClass.kt") + public void testLocalCapturedInLambdaInInnerClassInLocalClass() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/localCapturedInLambdaInInnerClassInLocalClass.kt"); + } + + @Test + @TestMetadata("localCapturedInLambdaInLocalClass.kt") + public void testLocalCapturedInLambdaInLocalClass() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/localCapturedInLambdaInLocalClass.kt"); + } + + @Test + @TestMetadata("localFunctionCapturedInLambda.kt") + public void testLocalFunctionCapturedInLambda() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/localFunctionCapturedInLambda.kt"); + } + + @Test + @TestMetadata("outerAndLocalCapturedInLocalClass.kt") + public void testOuterAndLocalCapturedInLocalClass() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerAndLocalCapturedInLocalClass.kt"); + } + + @Test + @TestMetadata("outerCapturedAsImplicitThisInBoundReference.kt") + public void testOuterCapturedAsImplicitThisInBoundReference() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedAsImplicitThisInBoundReference.kt"); + } + + @Test + @TestMetadata("outerCapturedInFunctionLiteral.kt") + public void testOuterCapturedInFunctionLiteral() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInFunctionLiteral.kt"); + } + + @Test + @TestMetadata("outerCapturedInInlineLambda.kt") + public void testOuterCapturedInInlineLambda() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInInlineLambda.kt"); + } + + @Test + @TestMetadata("outerCapturedInInlineLambda2.kt") + public void testOuterCapturedInInlineLambda2() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInInlineLambda2.kt"); + } + + @Test + @TestMetadata("outerCapturedInLambda.kt") + public void testOuterCapturedInLambda() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInLambda.kt"); + } + + @Test + @TestMetadata("outerCapturedInLambda2.kt") + public void testOuterCapturedInLambda2() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInLambda2.kt"); + } + + @Test + @TestMetadata("outerCapturedInLambdaInSecondaryConstructor.kt") + public void testOuterCapturedInLambdaInSecondaryConstructor() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInLambdaInSecondaryConstructor.kt"); + } + + @Test + @TestMetadata("outerCapturedInLambdaInSubExpression.kt") + public void testOuterCapturedInLambdaInSubExpression() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInLambdaInSubExpression.kt"); + } + + @Test + @TestMetadata("outerCapturedInLocalClass.kt") + public void testOuterCapturedInLocalClass() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInLocalClass.kt"); + } + + @Test + @TestMetadata("outerCapturedInNestedLambda.kt") + public void testOuterCapturedInNestedLambda() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInNestedLambda.kt"); + } + + @Test + @TestMetadata("outerCapturedInNestedObject.kt") + public void testOuterCapturedInNestedObject() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInNestedObject.kt"); + } + + @Test + @TestMetadata("outerCapturedInObject.kt") + public void testOuterCapturedInObject() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInObject.kt"); + } + + @Test + @TestMetadata("outerCapturedInObject2.kt") + public void testOuterCapturedInObject2() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInObject2.kt"); + } + + @Test + @TestMetadata("outerCapturedInPrimaryConstructorDefaultParameter.kt") + public void testOuterCapturedInPrimaryConstructorDefaultParameter() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInPrimaryConstructorDefaultParameter.kt"); + } + + @Test + @TestMetadata("outerCapturedInSecondaryConstructorDefaultParameter.kt") + public void testOuterCapturedInSecondaryConstructorDefaultParameter() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerCapturedInSecondaryConstructorDefaultParameter.kt"); + } + + @Test + @TestMetadata("outerEnumEntryCapturedInLambdaInInnerClass.kt") + public void testOuterEnumEntryCapturedInLambdaInInnerClass() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/outerEnumEntryCapturedInLambdaInInnerClass.kt"); + } + + @Test + @TestMetadata("properValueCapturedByClosure1.kt") + public void testProperValueCapturedByClosure1() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/properValueCapturedByClosure1.kt"); + } + + @Test + @TestMetadata("properValueCapturedByClosure2.kt") + public void testProperValueCapturedByClosure2() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/properValueCapturedByClosure2.kt"); + } + + @Test + @TestMetadata("referenceToCapturedVariablesInMultipleLambdas.kt") + public void testReferenceToCapturedVariablesInMultipleLambdas() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureInSuperConstructorCall/referenceToCapturedVariablesInMultipleLambdas.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/closures/captureOuterProperty") + @TestDataPath("$PROJECT_ROOT") + public class CaptureOuterProperty { + @Test + public void testAllFilesPresentInCaptureOuterProperty() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/captureOuterProperty"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("captureFunctionInProperty.kt") + public void testCaptureFunctionInProperty() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureOuterProperty/captureFunctionInProperty.kt"); + } + + @Test + @TestMetadata("inFunction.kt") + public void testInFunction() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureOuterProperty/inFunction.kt"); + } + + @Test + @TestMetadata("inProperty.kt") + public void testInProperty() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureOuterProperty/inProperty.kt"); + } + + @Test + @TestMetadata("inPropertyDeepObjectChain.kt") + public void testInPropertyDeepObjectChain() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureOuterProperty/inPropertyDeepObjectChain.kt"); + } + + @Test + @TestMetadata("inPropertyFromSuperClass.kt") + public void testInPropertyFromSuperClass() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureOuterProperty/inPropertyFromSuperClass.kt"); + } + + @Test + @TestMetadata("inPropertyFromSuperSuperClass.kt") + public void testInPropertyFromSuperSuperClass() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureOuterProperty/inPropertyFromSuperSuperClass.kt"); + } + + @Test + @TestMetadata("kt4176.kt") + public void testKt4176() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureOuterProperty/kt4176.kt"); + } + + @Test + @TestMetadata("kt4656.kt") + public void testKt4656() throws Exception { + runTest("compiler/testData/codegen/box/closures/captureOuterProperty/kt4656.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/closures/capturedVarsOptimization") + @TestDataPath("$PROJECT_ROOT") + public class CapturedVarsOptimization { + @Test + public void testAllFilesPresentInCapturedVarsOptimization() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/capturedVarsOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("capturedInCrossinline.kt") + public void testCapturedInCrossinline() throws Exception { + runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/capturedInCrossinline.kt"); + } + + @Test + @TestMetadata("capturedInInlineOnlyAssign.kt") + public void testCapturedInInlineOnlyAssign() throws Exception { + runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/capturedInInlineOnlyAssign.kt"); + } + + @Test + @TestMetadata("capturedInInlineOnlyCAO.kt") + public void testCapturedInInlineOnlyCAO() throws Exception { + runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/capturedInInlineOnlyCAO.kt"); + } + + @Test + @TestMetadata("capturedInInlineOnlyIncrDecr.kt") + public void testCapturedInInlineOnlyIncrDecr() throws Exception { + runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/capturedInInlineOnlyIncrDecr.kt"); + } + + @Test + @TestMetadata("capturedInInlineOnlyIndexedCAO.kt") + public void testCapturedInInlineOnlyIndexedCAO() throws Exception { + runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/capturedInInlineOnlyIndexedCAO.kt"); + } + + @Test + @TestMetadata("capturedVarsOfSize2.kt") + public void testCapturedVarsOfSize2() throws Exception { + runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/capturedVarsOfSize2.kt"); + } + + @Test + @TestMetadata("kt17200.kt") + public void testKt17200() throws Exception { + runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/kt17200.kt"); + } + + @Test + @TestMetadata("kt17588.kt") + public void testKt17588() throws Exception { + runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/kt17588.kt"); + } + + @Test + @TestMetadata("kt44347.kt") + public void testKt44347() throws Exception { + runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/kt44347.kt"); + } + + @Test + @TestMetadata("kt45446.kt") + public void testKt45446() throws Exception { + runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/kt45446.kt"); + } + + @Test + @TestMetadata("sharedSlotsWithCapturedVars.kt") + public void testSharedSlotsWithCapturedVars() throws Exception { + runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/sharedSlotsWithCapturedVars.kt"); + } + + @Test + @TestMetadata("withCoroutines.kt") + public void testWithCoroutines() throws Exception { + runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/withCoroutines.kt"); + } + + @Test + @TestMetadata("withCoroutinesNoStdLib.kt") + public void testWithCoroutinesNoStdLib() throws Exception { + runTest("compiler/testData/codegen/box/closures/capturedVarsOptimization/withCoroutinesNoStdLib.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/closures/closureInsideClosure") + @TestDataPath("$PROJECT_ROOT") + public class ClosureInsideClosure { + @Test + public void testAllFilesPresentInClosureInsideClosure() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/closures/closureInsideClosure"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("localFunInsideLocalFun.kt") + public void testLocalFunInsideLocalFun() throws Exception { + runTest("compiler/testData/codegen/box/closures/closureInsideClosure/localFunInsideLocalFun.kt"); + } + + @Test + @TestMetadata("localFunInsideLocalFunDifferentSignatures.kt") + public void testLocalFunInsideLocalFunDifferentSignatures() throws Exception { + runTest("compiler/testData/codegen/box/closures/closureInsideClosure/localFunInsideLocalFunDifferentSignatures.kt"); + } + + @Test + @TestMetadata("propertyAndFunctionNameClash.kt") + public void testPropertyAndFunctionNameClash() throws Exception { + runTest("compiler/testData/codegen/box/closures/closureInsideClosure/propertyAndFunctionNameClash.kt"); + } + + @Test + @TestMetadata("threeLevels.kt") + public void testThreeLevels() throws Exception { + runTest("compiler/testData/codegen/box/closures/closureInsideClosure/threeLevels.kt"); + } + + @Test + @TestMetadata("threeLevelsDifferentSignatures.kt") + public void testThreeLevelsDifferentSignatures() throws Exception { + runTest("compiler/testData/codegen/box/closures/closureInsideClosure/threeLevelsDifferentSignatures.kt"); + } + + @Test + @TestMetadata("varAsFunInsideLocalFun.kt") + public void testVarAsFunInsideLocalFun() throws Exception { + runTest("compiler/testData/codegen/box/closures/closureInsideClosure/varAsFunInsideLocalFun.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/collectionLiterals") + @TestDataPath("$PROJECT_ROOT") + public class CollectionLiterals { + @Test + public void testAllFilesPresentInCollectionLiterals() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collectionLiterals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/collections") + @TestDataPath("$PROJECT_ROOT") + public class Collections { + @Test + @TestMetadata("addCollectionStubWithCovariantOverride.kt") + public void testAddCollectionStubWithCovariantOverride() throws Exception { + runTest("compiler/testData/codegen/box/collections/addCollectionStubWithCovariantOverride.kt"); + } + + @Test + public void testAllFilesPresentInCollections() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/collections"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("inSetWithSmartCast.kt") + public void testInSetWithSmartCast() throws Exception { + runTest("compiler/testData/codegen/box/collections/inSetWithSmartCast.kt"); + } + + @Test + @TestMetadata("inheritFromAbstractMutableListInt.kt") + public void testInheritFromAbstractMutableListInt() throws Exception { + runTest("compiler/testData/codegen/box/collections/inheritFromAbstractMutableListInt.kt"); + } + + @Test + @TestMetadata("internalRemove.kt") + public void testInternalRemove() throws Exception { + runTest("compiler/testData/codegen/box/collections/internalRemove.kt"); + } + + @Test + @TestMetadata("kt41123.kt") + public void testKt41123() throws Exception { + runTest("compiler/testData/codegen/box/collections/kt41123.kt"); + } + + @Test + @TestMetadata("removeClash.kt") + public void testRemoveClash() throws Exception { + runTest("compiler/testData/codegen/box/collections/removeClash.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/companion") + @TestDataPath("$PROJECT_ROOT") + public class Companion { + @Test + public void testAllFilesPresentInCompanion() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/companion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("delegatedPropertyOnCompanion.kt") + public void testDelegatedPropertyOnCompanion() throws Exception { + runTest("compiler/testData/codegen/box/companion/delegatedPropertyOnCompanion.kt"); + } + + @Test + @TestMetadata("genericLambdaOnStringCompanion.kt") + public void testGenericLambdaOnStringCompanion() throws Exception { + runTest("compiler/testData/codegen/box/companion/genericLambdaOnStringCompanion.kt"); + } + + @Test + @TestMetadata("inlineFunctionCompanionPropertyAccess.kt") + public void testInlineFunctionCompanionPropertyAccess() throws Exception { + runTest("compiler/testData/codegen/box/companion/inlineFunctionCompanionPropertyAccess.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/compatibility") + @TestDataPath("$PROJECT_ROOT") + public class Compatibility { + @Test + public void testAllFilesPresentInCompatibility() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/compatibility"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("privateCompanionObject.kt") + public void testPrivateCompanionObject() throws Exception { + runTest("compiler/testData/codegen/box/compatibility/privateCompanionObject.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/constants") + @TestDataPath("$PROJECT_ROOT") + public class Constants { + @Test + public void testAllFilesPresentInConstants() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constants"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("comparisonFalse.kt") + public void testComparisonFalse() throws Exception { + runTest("compiler/testData/codegen/box/constants/comparisonFalse.kt"); + } + + @Test + @TestMetadata("constValFromAnotherModuleInConsVal.kt") + public void testConstValFromAnotherModuleInConsVal() throws Exception { + runTest("compiler/testData/codegen/box/constants/constValFromAnotherModuleInConsVal.kt"); + } + + @Test + @TestMetadata("constantsInWhen.kt") + public void testConstantsInWhen() throws Exception { + runTest("compiler/testData/codegen/box/constants/constantsInWhen.kt"); + } + + @Test + @TestMetadata("divisionByZero.kt") + public void testDivisionByZero() throws Exception { + runTest("compiler/testData/codegen/box/constants/divisionByZero.kt"); + } + + @Test + @TestMetadata("doNotTriggerInit.kt") + public void testDoNotTriggerInit() throws Exception { + runTest("compiler/testData/codegen/box/constants/doNotTriggerInit.kt"); + } + + @Test + @TestMetadata("float.kt") + public void testFloat() throws Exception { + runTest("compiler/testData/codegen/box/constants/float.kt"); + } + + @Test + @TestMetadata("foldingBinaryOpsUnsigned.kt") + public void testFoldingBinaryOpsUnsigned() throws Exception { + runTest("compiler/testData/codegen/box/constants/foldingBinaryOpsUnsigned.kt"); + } + + @Test + @TestMetadata("foldingBinaryOpsUnsignedConst.kt") + public void testFoldingBinaryOpsUnsignedConst() throws Exception { + runTest("compiler/testData/codegen/box/constants/foldingBinaryOpsUnsignedConst.kt"); + } + + @Test + @TestMetadata("kt9532.kt") + public void testKt9532() throws Exception { + runTest("compiler/testData/codegen/box/constants/kt9532.kt"); + } + + @Test + @TestMetadata("literalToLongConversion.kt") + public void testLiteralToLongConversion() throws Exception { + runTest("compiler/testData/codegen/box/constants/literalToLongConversion.kt"); + } + + @Test + @TestMetadata("long.kt") + public void testLong() throws Exception { + runTest("compiler/testData/codegen/box/constants/long.kt"); + } + + @Test + @TestMetadata("privateConst.kt") + public void testPrivateConst() throws Exception { + runTest("compiler/testData/codegen/box/constants/privateConst.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/constructor") + @TestDataPath("$PROJECT_ROOT") + public class Constructor { + @Test + public void testAllFilesPresentInConstructor() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constructor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/constructorCall") + @TestDataPath("$PROJECT_ROOT") + public class ConstructorCall { + @Test + public void testAllFilesPresentInConstructorCall() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/constructorCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/contracts") + @TestDataPath("$PROJECT_ROOT") + public class Contracts { + @Test + public void testAllFilesPresentInContracts() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/contracts"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("constructorArgument.kt") + public void testConstructorArgument() throws Exception { + runTest("compiler/testData/codegen/box/contracts/constructorArgument.kt"); + } + + @Test + @TestMetadata("destructuredVariable.kt") + public void testDestructuredVariable() throws Exception { + runTest("compiler/testData/codegen/box/contracts/destructuredVariable.kt"); + } + + @Test + @TestMetadata("exactlyOnceNotInline.kt") + public void testExactlyOnceNotInline() throws Exception { + runTest("compiler/testData/codegen/box/contracts/exactlyOnceNotInline.kt"); + } + + @Test + @TestMetadata("exception.kt") + public void testException() throws Exception { + runTest("compiler/testData/codegen/box/contracts/exception.kt"); + } + + @Test + @TestMetadata("fieldInConstructorParens.kt") + public void testFieldInConstructorParens() throws Exception { + runTest("compiler/testData/codegen/box/contracts/fieldInConstructorParens.kt"); + } + + @Test + @TestMetadata("fieldReadInConstructor.kt") + public void testFieldReadInConstructor() throws Exception { + runTest("compiler/testData/codegen/box/contracts/fieldReadInConstructor.kt"); + } + + @Test + @TestMetadata("forLoop.kt") + public void testForLoop() throws Exception { + runTest("compiler/testData/codegen/box/contracts/forLoop.kt"); + } + + @Test + @TestMetadata("functionParameter.kt") + public void testFunctionParameter() throws Exception { + runTest("compiler/testData/codegen/box/contracts/functionParameter.kt"); + } + + @Test + @TestMetadata("kt39374.kt") + public void testKt39374() throws Exception { + runTest("compiler/testData/codegen/box/contracts/kt39374.kt"); + } + + @Test + @TestMetadata("kt45236.kt") + public void testKt45236() throws Exception { + runTest("compiler/testData/codegen/box/contracts/kt45236.kt"); + } + + @Test + @TestMetadata("kt47168.kt") + public void testKt47168() throws Exception { + runTest("compiler/testData/codegen/box/contracts/kt47168.kt"); + } + + @Test + @TestMetadata("kt47300.kt") + public void testKt47300() throws Exception { + runTest("compiler/testData/codegen/box/contracts/kt47300.kt"); + } + + @Test + @TestMetadata("lambdaParameter.kt") + public void testLambdaParameter() throws Exception { + runTest("compiler/testData/codegen/box/contracts/lambdaParameter.kt"); + } + + @Test + @TestMetadata("listAppend.kt") + public void testListAppend() throws Exception { + runTest("compiler/testData/codegen/box/contracts/listAppend.kt"); + } + + @Test + @TestMetadata("nestedLambdaInNonInlineCallExactlyOnce.kt") + public void testNestedLambdaInNonInlineCallExactlyOnce() throws Exception { + runTest("compiler/testData/codegen/box/contracts/nestedLambdaInNonInlineCallExactlyOnce.kt"); + } + + @Test + @TestMetadata("valInWhen.kt") + public void testValInWhen() throws Exception { + runTest("compiler/testData/codegen/box/contracts/valInWhen.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/controlStructures") + @TestDataPath("$PROJECT_ROOT") + public class ControlStructures { + @Test + public void testAllFilesPresentInControlStructures() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("bottles.kt") + public void testBottles() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/bottles.kt"); + } + + @Test + @TestMetadata("breakInFinally.kt") + public void testBreakInFinally() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakInFinally.kt"); + } + + @Test + @TestMetadata("breakInWhen.kt") + public void testBreakInWhen() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakInWhen.kt"); + } + + @Test + @TestMetadata("compareBoxedIntegerToZero.kt") + public void testCompareBoxedIntegerToZero() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/compareBoxedIntegerToZero.kt"); + } + + @Test + @TestMetadata("conditionOfEmptyIf.kt") + public void testConditionOfEmptyIf() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/conditionOfEmptyIf.kt"); + } + + @Test + @TestMetadata("continueInExpr.kt") + public void testContinueInExpr() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/continueInExpr.kt"); + } + + @Test + @TestMetadata("continueInFor.kt") + public void testContinueInFor() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/continueInFor.kt"); + } + + @Test + @TestMetadata("continueInForCondition.kt") + public void testContinueInForCondition() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/continueInForCondition.kt"); + } + + @Test + @TestMetadata("continueInWhen.kt") + public void testContinueInWhen() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/continueInWhen.kt"); + } + + @Test + @TestMetadata("continueInWhile.kt") + public void testContinueInWhile() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/continueInWhile.kt"); + } + + @Test + @TestMetadata("continueToLabelInFor.kt") + public void testContinueToLabelInFor() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/continueToLabelInFor.kt"); + } + + @Test + @TestMetadata("doWhile.kt") + public void testDoWhile() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/doWhile.kt"); + } + + @Test + @TestMetadata("doWhileFib.kt") + public void testDoWhileFib() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/doWhileFib.kt"); + } + + @Test + @TestMetadata("doWhileWithContinue.kt") + public void testDoWhileWithContinue() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/doWhileWithContinue.kt"); + } + + @Test + @TestMetadata("emptyDoWhile.kt") + public void testEmptyDoWhile() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/emptyDoWhile.kt"); + } + + @Test + @TestMetadata("emptyFor.kt") + public void testEmptyFor() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/emptyFor.kt"); + } + + @Test + @TestMetadata("emptyWhile.kt") + public void testEmptyWhile() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/emptyWhile.kt"); + } + + @Test + @TestMetadata("factorialTest.kt") + public void testFactorialTest() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/factorialTest.kt"); + } + + @Test + @TestMetadata("finallyOnEmptyReturn.kt") + public void testFinallyOnEmptyReturn() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/finallyOnEmptyReturn.kt"); + } + + @Test + @TestMetadata("forArrayList.kt") + public void testForArrayList() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forArrayList.kt"); + } + + @Test + @TestMetadata("forArrayListMultiDecl.kt") + public void testForArrayListMultiDecl() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forArrayListMultiDecl.kt"); + } + + @Test + @TestMetadata("forInCharSequence.kt") + public void testForInCharSequence() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInCharSequence.kt"); + } + + @Test + @TestMetadata("forInCharSequenceMut.kt") + public void testForInCharSequenceMut() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceMut.kt"); + } + + @Test + @TestMetadata("forInSmartCastToArray.kt") + public void testForInSmartCastToArray() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInSmartCastToArray.kt"); + } + + @Test + @TestMetadata("forLoopMemberExtensionAll.kt") + public void testForLoopMemberExtensionAll() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forLoopMemberExtensionAll.kt"); + } + + @Test + @TestMetadata("forLoopMemberExtensionHasNext.kt") + public void testForLoopMemberExtensionHasNext() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forLoopMemberExtensionHasNext.kt"); + } + + @Test + @TestMetadata("forLoopMemberExtensionNext.kt") + public void testForLoopMemberExtensionNext() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forLoopMemberExtensionNext.kt"); + } + + @Test + @TestMetadata("forNullableCharInString.kt") + public void testForNullableCharInString() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forNullableCharInString.kt"); + } + + @Test + @TestMetadata("forUserType.kt") + public void testForUserType() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forUserType.kt"); + } + + @Test + @TestMetadata("ifConst1.kt") + public void testIfConst1() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/ifConst1.kt"); + } + + @Test + @TestMetadata("ifConst2.kt") + public void testIfConst2() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/ifConst2.kt"); + } + + @Test + @TestMetadata("ifIncompatibleBranches.kt") + public void testIfIncompatibleBranches() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/ifIncompatibleBranches.kt"); + } + + @Test + @TestMetadata("inRangeConditionsInWhen.kt") + public void testInRangeConditionsInWhen() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/inRangeConditionsInWhen.kt"); + } + + @Test + @TestMetadata("kt12908.kt") + public void testKt12908() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt12908.kt"); + } + + @Test + @TestMetadata("kt12908_2.kt") + public void testKt12908_2() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt12908_2.kt"); + } + + @Test + @TestMetadata("kt1441.kt") + public void testKt1441() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt1441.kt"); + } + + @Test + @TestMetadata("kt14839.kt") + public void testKt14839() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt14839.kt"); + } + + @Test + @TestMetadata("kt15726.kt") + public void testKt15726() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt15726.kt"); + } + + @Test + @TestMetadata("kt1688.kt") + public void testKt1688() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt1688.kt"); + } + + @Test + @TestMetadata("kt17110.kt") + public void testKt17110() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt17110.kt"); + } + + @Test + @TestMetadata("kt1742.kt") + public void testKt1742() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt1742.kt"); + } + + @Test + @TestMetadata("kt17590.kt") + public void testKt17590() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt17590.kt"); + } + + @Test + @TestMetadata("kt17590_long.kt") + public void testKt17590_long() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt17590_long.kt"); + } + + @Test + @TestMetadata("kt1899.kt") + public void testKt1899() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt1899.kt"); + } + + @Test + @TestMetadata("kt2147.kt") + public void testKt2147() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt2147.kt"); + } + + @Test + @TestMetadata("kt2259.kt") + public void testKt2259() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt2259.kt"); + } + + @Test + @TestMetadata("kt2291.kt") + public void testKt2291() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt2291.kt"); + } + + @Test + @TestMetadata("kt237.kt") + public void testKt237() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt237.kt"); + } + + @Test + @TestMetadata("kt2416.kt") + public void testKt2416() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt2416.kt"); + } + + @Test + @TestMetadata("kt2577.kt") + public void testKt2577() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt2577.kt"); + } + + @Test + @TestMetadata("kt2597.kt") + public void testKt2597() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt2597.kt"); + } + + @Test + @TestMetadata("kt299.kt") + public void testKt299() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt299.kt"); + } + + @Test + @TestMetadata("kt3087.kt") + public void testKt3087() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt3087.kt"); + } + + @Test + @TestMetadata("kt3203_1.kt") + public void testKt3203_1() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt3203_1.kt"); + } + + @Test + @TestMetadata("kt3203_2.kt") + public void testKt3203_2() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt3203_2.kt"); + } + + @Test + @TestMetadata("kt3273.kt") + public void testKt3273() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt3273.kt"); + } + + @Test + @TestMetadata("kt3280.kt") + public void testKt3280() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt3280.kt"); + } + + @Test + @TestMetadata("kt416.kt") + public void testKt416() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt416.kt"); + } + + @Test + @TestMetadata("kt42455.kt") + public void testKt42455() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt42455.kt"); + } + + @Test + @TestMetadata("kt47245.kt") + public void testKt47245() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt47245.kt"); + } + + @Test + @TestMetadata("kt513.kt") + public void testKt513() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt513.kt"); + } + + @Test + @TestMetadata("kt628.kt") + public void testKt628() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt628.kt"); + } + + @Test + @TestMetadata("kt769.kt") + public void testKt769() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt769.kt"); + } + + @Test + @TestMetadata("kt772.kt") + public void testKt772() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt772.kt"); + } + + @Test + @TestMetadata("kt773.kt") + public void testKt773() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt773.kt"); + } + + @Test + @TestMetadata("kt8148.kt") + public void testKt8148() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt8148.kt"); + } + + @Test + @TestMetadata("kt8148_break.kt") + public void testKt8148_break() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt8148_break.kt"); + } + + @Test + @TestMetadata("kt8148_continue.kt") + public void testKt8148_continue() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt8148_continue.kt"); + } + + @Test + @TestMetadata("kt870.kt") + public void testKt870() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt870.kt"); + } + + @Test + @TestMetadata("kt9022Return.kt") + public void testKt9022Return() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt9022Return.kt"); + } + + @Test + @TestMetadata("kt9022Throw.kt") + public void testKt9022Throw() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt9022Throw.kt"); + } + + @Test + @TestMetadata("kt910.kt") + public void testKt910() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt910.kt"); + } + + @Test + @TestMetadata("kt958.kt") + public void testKt958() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/kt958.kt"); + } + + @Test + @TestMetadata("longRange.kt") + public void testLongRange() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/longRange.kt"); + } + + @Test + @TestMetadata("parameterWithNameForFunctionType.kt") + public void testParameterWithNameForFunctionType() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/parameterWithNameForFunctionType.kt"); + } + + @Test + @TestMetadata("quicksort.kt") + public void testQuicksort() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/quicksort.kt"); + } + + @Test + @TestMetadata("tcbInEliminatedCondition.kt") + public void testTcbInEliminatedCondition() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tcbInEliminatedCondition.kt"); + } + + @Test + @TestMetadata("tryCatchExpression.kt") + public void testTryCatchExpression() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchExpression.kt"); + } + + @Test + @TestMetadata("tryCatchFinally.kt") + public void testTryCatchFinally() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchFinally.kt"); + } + + @Test + @TestMetadata("tryCatchFinallyChain.kt") + public void testTryCatchFinallyChain() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchFinallyChain.kt"); + } + + @Test + @TestMetadata("tryFinally.kt") + public void testTryFinally() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryFinally.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions") + @TestDataPath("$PROJECT_ROOT") + public class BreakContinueInExpressions { + @Test + public void testAllFilesPresentInBreakContinueInExpressions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("breakFromOuter.kt") + public void testBreakFromOuter() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/breakFromOuter.kt"); + } + + @Test + @TestMetadata("breakInDoWhile.kt") + public void testBreakInDoWhile() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/breakInDoWhile.kt"); + } + + @Test + @TestMetadata("breakInExpr.kt") + public void testBreakInExpr() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/breakInExpr.kt"); + } + + @Test + @TestMetadata("breakInLoopConditions.kt") + public void testBreakInLoopConditions() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/breakInLoopConditions.kt"); + } + + @Test + @TestMetadata("continueInDoWhile.kt") + public void testContinueInDoWhile() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/continueInDoWhile.kt"); + } + + @Test + @TestMetadata("continueInExpr.kt") + public void testContinueInExpr() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/continueInExpr.kt"); + } + + @Test + @TestMetadata("inlineWithStack.kt") + public void testInlineWithStack() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/inlineWithStack.kt"); + } + + @Test + @TestMetadata("innerLoopWithStack.kt") + public void testInnerLoopWithStack() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/innerLoopWithStack.kt"); + } + + @Test + @TestMetadata("kt14581.kt") + public void testKt14581() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/kt14581.kt"); + } + + @Test + @TestMetadata("kt16713.kt") + public void testKt16713() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/kt16713.kt"); + } + + @Test + @TestMetadata("kt16713_2.kt") + public void testKt16713_2() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/kt16713_2.kt"); + } + + @Test + @TestMetadata("kt17384.kt") + public void testKt17384() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/kt17384.kt"); + } + + @Test + @TestMetadata("kt45704_elvisInInlineFun.kt") + public void testKt45704_elvisInInlineFun() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/kt45704_elvisInInlineFun.kt"); + } + + @Test + @TestMetadata("kt9022And.kt") + public void testKt9022And() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/kt9022And.kt"); + } + + @Test + @TestMetadata("kt9022Or.kt") + public void testKt9022Or() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/kt9022Or.kt"); + } + + @Test + @TestMetadata("pathologicalDoWhile.kt") + public void testPathologicalDoWhile() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/pathologicalDoWhile.kt"); + } + + @Test + @TestMetadata("popSizes.kt") + public void testPopSizes() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/popSizes.kt"); + } + + @Test + @TestMetadata("tryFinally1.kt") + public void testTryFinally1() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/tryFinally1.kt"); + } + + @Test + @TestMetadata("tryFinally2.kt") + public void testTryFinally2() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/tryFinally2.kt"); + } + + @Test + @TestMetadata("whileTrueBreak.kt") + public void testWhileTrueBreak() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/whileTrueBreak.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/inlinedBreakContinue") + @TestDataPath("$PROJECT_ROOT") + public class InlinedBreakContinue { + @Test + public void testAllFilesPresentInInlinedBreakContinue() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/inlinedBreakContinue"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("initializerBlock.kt") + public void testInitializerBlock() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/inlinedBreakContinue/initializerBlock.kt"); + } + + @Test + @TestMetadata("inlineFunctionWithMultipleParameters.kt") + public void testInlineFunctionWithMultipleParameters() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/inlinedBreakContinue/inlineFunctionWithMultipleParameters.kt"); + } + + @Test + @TestMetadata("lambdaPassedToInlineFunction.kt") + public void testLambdaPassedToInlineFunction() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/inlinedBreakContinue/lambdaPassedToInlineFunction.kt"); + } + + @Test + @TestMetadata("loopWithinInlineFunction.kt") + public void testLoopWithinInlineFunction() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/inlinedBreakContinue/loopWithinInlineFunction.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/inlinedBreakContinue/simple.kt"); + } + + @Test + @TestMetadata("stdlibFunctions.kt") + public void testStdlibFunctions() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/inlinedBreakContinue/stdlibFunctions.kt"); + } + + @Test + @TestMetadata("withReturnValue.kt") + public void testWithReturnValue() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/breakContinueInExpressions/inlinedBreakContinue/withReturnValue.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/controlStructures/forInArray") + @TestDataPath("$PROJECT_ROOT") + public class ForInArray { + @Test + public void testAllFilesPresentInForInArray() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArray"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("forInArraySpecializedToUntil.kt") + public void testForInArraySpecializedToUntil() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArray/forInArraySpecializedToUntil.kt"); + } + + @Test + @TestMetadata("forInArrayWithArrayPropertyUpdatedInLoopBody.kt") + public void testForInArrayWithArrayPropertyUpdatedInLoopBody() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArray/forInArrayWithArrayPropertyUpdatedInLoopBody.kt"); + } + + @Test + @TestMetadata("forInArrayWithArrayVarUpdatedInLoopBody13.kt") + public void testForInArrayWithArrayVarUpdatedInLoopBody13() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArray/forInArrayWithArrayVarUpdatedInLoopBody13.kt"); + } + + @Test + @TestMetadata("forInDelegatedPropertyUpdatedInLoopBody.kt") + public void testForInDelegatedPropertyUpdatedInLoopBody() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArray/forInDelegatedPropertyUpdatedInLoopBody.kt"); + } + + @Test + @TestMetadata("forInDoubleArrayWithUpcast.kt") + public void testForInDoubleArrayWithUpcast() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArray/forInDoubleArrayWithUpcast.kt"); + } + + @Test + @TestMetadata("forInFieldUpdatedInLoopBody.kt") + public void testForInFieldUpdatedInLoopBody() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArray/forInFieldUpdatedInLoopBody.kt"); + } + + @Test + @TestMetadata("forInInlineClassArrayWithUpcast.kt") + public void testForInInlineClassArrayWithUpcast() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArray/forInInlineClassArrayWithUpcast.kt"); + } + + @Test + @TestMetadata("forIntArray.kt") + public void testForIntArray() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArray/forIntArray.kt"); + } + + @Test + @TestMetadata("forNullableIntArray.kt") + public void testForNullableIntArray() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArray/forNullableIntArray.kt"); + } + + @Test + @TestMetadata("forPrimitiveIntArray.kt") + public void testForPrimitiveIntArray() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArray/forPrimitiveIntArray.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex") + @TestDataPath("$PROJECT_ROOT") + public class ForInArrayWithIndex { + @Test + public void testAllFilesPresentInForInArrayWithIndex() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("forInArrayOfObjectArrayWithIndex.kt") + public void testForInArrayOfObjectArrayWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInArrayOfObjectArrayWithIndex.kt"); + } + + @Test + @TestMetadata("forInArrayOfPrimArrayWithIndex.kt") + public void testForInArrayOfPrimArrayWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInArrayOfPrimArrayWithIndex.kt"); + } + + @Test + @TestMetadata("forInArrayWithIndexBreakAndContinue.kt") + public void testForInArrayWithIndexBreakAndContinue() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInArrayWithIndexBreakAndContinue.kt"); + } + + @Test + @TestMetadata("forInArrayWithIndexContinuesAsUnmodified.kt") + public void testForInArrayWithIndexContinuesAsUnmodified() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInArrayWithIndexContinuesAsUnmodified.kt"); + } + + @Test + @TestMetadata("forInArrayWithIndexNoElementVar.kt") + public void testForInArrayWithIndexNoElementVar() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInArrayWithIndexNoElementVar.kt"); + } + + @Test + @TestMetadata("forInArrayWithIndexNoIndexOrElementVar.kt") + public void testForInArrayWithIndexNoIndexOrElementVar() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInArrayWithIndexNoIndexOrElementVar.kt"); + } + + @Test + @TestMetadata("forInArrayWithIndexNoIndexVar.kt") + public void testForInArrayWithIndexNoIndexVar() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInArrayWithIndexNoIndexVar.kt"); + } + + @Test + @TestMetadata("forInArrayWithIndexNotDestructured.kt") + public void testForInArrayWithIndexNotDestructured() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInArrayWithIndexNotDestructured.kt"); + } + + @Test + @TestMetadata("forInArrayWithIndexWithExplicitlyTypedIndexVariable.kt") + public void testForInArrayWithIndexWithExplicitlyTypedIndexVariable() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInArrayWithIndexWithExplicitlyTypedIndexVariable.kt"); + } + + @Test + @TestMetadata("forInByteArrayWithIndex.kt") + public void testForInByteArrayWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInByteArrayWithIndex.kt"); + } + + @Test + @TestMetadata("forInByteArrayWithIndexWithSmartCast.kt") + public void testForInByteArrayWithIndexWithSmartCast() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInByteArrayWithIndexWithSmartCast.kt"); + } + + @Test + @TestMetadata("forInEmptyArrayWithIndex.kt") + public void testForInEmptyArrayWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInEmptyArrayWithIndex.kt"); + } + + @Test + @TestMetadata("forInGenericArrayOfIntsWithIndex.kt") + public void testForInGenericArrayOfIntsWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInGenericArrayOfIntsWithIndex.kt"); + } + + @Test + @TestMetadata("forInGenericArrayOfIntsWithIndexWithSmartCast.kt") + public void testForInGenericArrayOfIntsWithIndexWithSmartCast() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInGenericArrayOfIntsWithIndexWithSmartCast.kt"); + } + + @Test + @TestMetadata("forInGenericArrayWithIndex.kt") + public void testForInGenericArrayWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInGenericArrayWithIndex.kt"); + } + + @Test + @TestMetadata("forInIntArrayWithIndex.kt") + public void testForInIntArrayWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInIntArrayWithIndex.kt"); + } + + @Test + @TestMetadata("forInIntArrayWithIndexWithSmartCast.kt") + public void testForInIntArrayWithIndexWithSmartCast() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInIntArrayWithIndexWithSmartCast.kt"); + } + + @Test + @TestMetadata("forInObjectArrayWithIndex.kt") + public void testForInObjectArrayWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInObjectArrayWithIndex.kt"); + } + + @Test + @TestMetadata("forInShortArrayWithIndex.kt") + public void testForInShortArrayWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInShortArrayWithIndex.kt"); + } + + @Test + @TestMetadata("forInShortArrayWithIndexWithSmartCast.kt") + public void testForInShortArrayWithIndexWithSmartCast() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInArrayWithIndex/forInShortArrayWithIndexWithSmartCast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex") + @TestDataPath("$PROJECT_ROOT") + public class ForInCharSequenceWithIndex { + @Test + public void testAllFilesPresentInForInCharSequenceWithIndex() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("forInCharSeqWithIndexStops.kt") + public void testForInCharSeqWithIndexStops() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInCharSeqWithIndexStops.kt"); + } + + @Test + @TestMetadata("forInCharSequenceTypeParameterWithIndex.kt") + public void testForInCharSequenceTypeParameterWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInCharSequenceTypeParameterWithIndex.kt"); + } + + @Test + @TestMetadata("forInCharSequenceWithIndex.kt") + public void testForInCharSequenceWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInCharSequenceWithIndex.kt"); + } + + @Test + @TestMetadata("forInCharSequenceWithIndexBreakAndContinue.kt") + public void testForInCharSequenceWithIndexBreakAndContinue() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInCharSequenceWithIndexBreakAndContinue.kt"); + } + + @Test + @TestMetadata("forInCharSequenceWithIndexCheckSideEffects.kt") + public void testForInCharSequenceWithIndexCheckSideEffects() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInCharSequenceWithIndexCheckSideEffects.kt"); + } + + @Test + @TestMetadata("forInCharSequenceWithIndexNoElementVarCheckSideEffects.kt") + public void testForInCharSequenceWithIndexNoElementVarCheckSideEffects() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInCharSequenceWithIndexNoElementVarCheckSideEffects.kt"); + } + + @Test + @TestMetadata("forInCharSequenceWithIndexNoIndexVarCheckSideEffects.kt") + public void testForInCharSequenceWithIndexNoIndexVarCheckSideEffects() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInCharSequenceWithIndexNoIndexVarCheckSideEffects.kt"); + } + + @Test + @TestMetadata("forInEmptyStringWithIndex.kt") + public void testForInEmptyStringWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInEmptyStringWithIndex.kt"); + } + + @Test + @TestMetadata("forInStringWithIndex.kt") + public void testForInStringWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInStringWithIndex.kt"); + } + + @Test + @TestMetadata("forInStringWithIndexNoElementVar.kt") + public void testForInStringWithIndexNoElementVar() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInStringWithIndexNoElementVar.kt"); + } + + @Test + @TestMetadata("forInStringWithIndexNoIndexOrElementVar.kt") + public void testForInStringWithIndexNoIndexOrElementVar() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInStringWithIndexNoIndexOrElementVar.kt"); + } + + @Test + @TestMetadata("forInStringWithIndexNoIndexVar.kt") + public void testForInStringWithIndexNoIndexVar() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInStringWithIndexNoIndexVar.kt"); + } + + @Test + @TestMetadata("forInStringWithIndexNotDestructured.kt") + public void testForInStringWithIndexNotDestructured() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInStringWithIndexNotDestructured.kt"); + } + + @Test + @TestMetadata("forInStringWithIndexWithExplicitlyTypedIndexVariable.kt") + public void testForInStringWithIndexWithExplicitlyTypedIndexVariable() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInCharSequenceWithIndex/forInStringWithIndexWithExplicitlyTypedIndexVariable.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex") + @TestDataPath("$PROJECT_ROOT") + public class ForInIterableWithIndex { + @Test + public void testAllFilesPresentInForInIterableWithIndex() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("forInEmptyListWithIndex.kt") + public void testForInEmptyListWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex/forInEmptyListWithIndex.kt"); + } + + @Test + @TestMetadata("forInIterableTypeParameterWithIndex.kt") + public void testForInIterableTypeParameterWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex/forInIterableTypeParameterWithIndex.kt"); + } + + @Test + @TestMetadata("forInIterableWithIndexCheckSideEffects.kt") + public void testForInIterableWithIndexCheckSideEffects() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex/forInIterableWithIndexCheckSideEffects.kt"); + } + + @Test + @TestMetadata("forInIterableWithIndexNoElementVarCheckSideEffects.kt") + public void testForInIterableWithIndexNoElementVarCheckSideEffects() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex/forInIterableWithIndexNoElementVarCheckSideEffects.kt"); + } + + @Test + @TestMetadata("forInIterableWithIndexNoIndexVarCheckSideEffects.kt") + public void testForInIterableWithIndexNoIndexVarCheckSideEffects() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex/forInIterableWithIndexNoIndexVarCheckSideEffects.kt"); + } + + @Test + @TestMetadata("forInListWithIndex.kt") + public void testForInListWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex/forInListWithIndex.kt"); + } + + @Test + @TestMetadata("forInListWithIndexBreak.kt") + public void testForInListWithIndexBreak() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex/forInListWithIndexBreak.kt"); + } + + @Test + @TestMetadata("forInListWithIndexBreakAndContinue.kt") + public void testForInListWithIndexBreakAndContinue() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex/forInListWithIndexBreakAndContinue.kt"); + } + + @Test + @TestMetadata("forInListWithIndexContinue.kt") + public void testForInListWithIndexContinue() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex/forInListWithIndexContinue.kt"); + } + + @Test + @TestMetadata("forInListWithIndexNoElementVar.kt") + public void testForInListWithIndexNoElementVar() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex/forInListWithIndexNoElementVar.kt"); + } + + @Test + @TestMetadata("forInListWithIndexNoIndexVar.kt") + public void testForInListWithIndexNoIndexVar() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex/forInListWithIndexNoIndexVar.kt"); + } + + @Test + @TestMetadata("forInListWithIndexWithExplicitlyTypedIndexVariable.kt") + public void testForInListWithIndexWithExplicitlyTypedIndexVariable() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInIterableWithIndex/forInListWithIndexWithExplicitlyTypedIndexVariable.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/controlStructures/forInIterator") + @TestDataPath("$PROJECT_ROOT") + public class ForInIterator { + @Test + public void testAllFilesPresentInForInIterator() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInIterator"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex") + @TestDataPath("$PROJECT_ROOT") + public class ForInSequenceWithIndex { + @Test + public void testAllFilesPresentInForInSequenceWithIndex() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("forInEmptySequenceWithIndex.kt") + public void testForInEmptySequenceWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex/forInEmptySequenceWithIndex.kt"); + } + + @Test + @TestMetadata("forInSequenceTypeParameterWithIndex.kt") + public void testForInSequenceTypeParameterWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex/forInSequenceTypeParameterWithIndex.kt"); + } + + @Test + @TestMetadata("forInSequenceWithIndex.kt") + public void testForInSequenceWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex/forInSequenceWithIndex.kt"); + } + + @Test + @TestMetadata("forInSequenceWithIndexBreakAndContinue.kt") + public void testForInSequenceWithIndexBreakAndContinue() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex/forInSequenceWithIndexBreakAndContinue.kt"); + } + + @Test + @TestMetadata("forInSequenceWithIndexCheckSideEffects.kt") + public void testForInSequenceWithIndexCheckSideEffects() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex/forInSequenceWithIndexCheckSideEffects.kt"); + } + + @Test + @TestMetadata("forInSequenceWithIndexNoElementVar.kt") + public void testForInSequenceWithIndexNoElementVar() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex/forInSequenceWithIndexNoElementVar.kt"); + } + + @Test + @TestMetadata("forInSequenceWithIndexNoElementVarCheckSideEffects.kt") + public void testForInSequenceWithIndexNoElementVarCheckSideEffects() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex/forInSequenceWithIndexNoElementVarCheckSideEffects.kt"); + } + + @Test + @TestMetadata("forInSequenceWithIndexNoIndexVar.kt") + public void testForInSequenceWithIndexNoIndexVar() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex/forInSequenceWithIndexNoIndexVar.kt"); + } + + @Test + @TestMetadata("forInSequenceWithIndexNoIndexVarCheckSideEffects.kt") + public void testForInSequenceWithIndexNoIndexVarCheckSideEffects() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex/forInSequenceWithIndexNoIndexVarCheckSideEffects.kt"); + } + + @Test + @TestMetadata("forInSequenceWithIndexWithExplicitlyTypedIndexVariable.kt") + public void testForInSequenceWithIndexWithExplicitlyTypedIndexVariable() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/forInSequenceWithIndex/forInSequenceWithIndexWithExplicitlyTypedIndexVariable.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/controlStructures/returnsNothing") + @TestDataPath("$PROJECT_ROOT") + public class ReturnsNothing { + @Test + public void testAllFilesPresentInReturnsNothing() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/returnsNothing"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("ifElse.kt") + public void testIfElse() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/returnsNothing/ifElse.kt"); + } + + @Test + @TestMetadata("inlineMethod.kt") + public void testInlineMethod() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/returnsNothing/inlineMethod.kt"); + } + + @Test + @TestMetadata("propertyGetter.kt") + public void testPropertyGetter() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/returnsNothing/propertyGetter.kt"); + } + + @Test + @TestMetadata("tryCatch.kt") + public void testTryCatch() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/returnsNothing/tryCatch.kt"); + } + + @Test + @TestMetadata("when.kt") + public void testWhen() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/returnsNothing/when.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/controlStructures/slowDsl") + @TestDataPath("$PROJECT_ROOT") + public class SlowDsl { + @Test + public void testAllFilesPresentInSlowDsl() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/slowDsl"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions") + @TestDataPath("$PROJECT_ROOT") + public class TryCatchInExpressions { + @Test + public void testAllFilesPresentInTryCatchInExpressions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("catch.kt") + public void testCatch() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/catch.kt"); + } + + @Test + @TestMetadata("complexChain.kt") + public void testComplexChain() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/complexChain.kt"); + } + + @Test + @TestMetadata("deadTryCatch.kt") + public void testDeadTryCatch() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/deadTryCatch.kt"); + } + + @Test + @TestMetadata("differentTypes.kt") + public void testDifferentTypes() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/differentTypes.kt"); + } + + @Test + @TestMetadata("expectException.kt") + public void testExpectException() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/expectException.kt"); + } + + @Test + @TestMetadata("finally.kt") + public void testFinally() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/finally.kt"); + } + + @Test + @TestMetadata("inlineTryCatch.kt") + public void testInlineTryCatch() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/inlineTryCatch.kt"); + } + + @Test + @TestMetadata("inlineTryExpr.kt") + public void testInlineTryExpr() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/inlineTryExpr.kt"); + } + + @Test + @TestMetadata("inlineTryFinally.kt") + public void testInlineTryFinally() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/inlineTryFinally.kt"); + } + + @Test + @TestMetadata("kt17572.kt") + public void testKt17572() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/kt17572.kt"); + } + + @Test + @TestMetadata("kt17572_2.kt") + public void testKt17572_2() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/kt17572_2.kt"); + } + + @Test + @TestMetadata("kt17572_2_ext.kt") + public void testKt17572_2_ext() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/kt17572_2_ext.kt"); + } + + @Test + @TestMetadata("kt17572_ext.kt") + public void testKt17572_ext() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/kt17572_ext.kt"); + } + + @Test + @TestMetadata("kt17572_nested.kt") + public void testKt17572_nested() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/kt17572_nested.kt"); + } + + @Test + @TestMetadata("kt17573.kt") + public void testKt17573() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/kt17573.kt"); + } + + @Test + @TestMetadata("kt17573_nested.kt") + public void testKt17573_nested() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/kt17573_nested.kt"); + } + + @Test + @TestMetadata("kt8608.kt") + public void testKt8608() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/kt8608.kt"); + } + + @Test + @TestMetadata("kt9644try.kt") + public void testKt9644try() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/kt9644try.kt"); + } + + @Test + @TestMetadata("multipleCatchBlocks.kt") + public void testMultipleCatchBlocks() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/multipleCatchBlocks.kt"); + } + + @Test + @TestMetadata("nonLocalReturnInTryFinally.kt") + public void testNonLocalReturnInTryFinally() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/nonLocalReturnInTryFinally.kt"); + } + + @Test + @TestMetadata("splitTry.kt") + public void testSplitTry() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/splitTry.kt"); + } + + @Test + @TestMetadata("splitTryCorner1.kt") + public void testSplitTryCorner1() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/splitTryCorner1.kt"); + } + + @Test + @TestMetadata("splitTryCorner2.kt") + public void testSplitTryCorner2() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/splitTryCorner2.kt"); + } + + @Test + @TestMetadata("try.kt") + public void testTry() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/try.kt"); + } + + @Test + @TestMetadata("tryAfterTry.kt") + public void testTryAfterTry() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryAfterTry.kt"); + } + + @Test + @TestMetadata("tryAndBreak.kt") + public void testTryAndBreak() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryAndBreak.kt"); + } + + @Test + @TestMetadata("tryAndContinue.kt") + public void testTryAndContinue() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryAndContinue.kt"); + } + + @Test + @TestMetadata("tryCatchAfterWhileTrue.kt") + public void testTryCatchAfterWhileTrue() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryCatchAfterWhileTrue.kt"); + } + + @Test + @TestMetadata("tryInsideCatch.kt") + public void testTryInsideCatch() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryInsideCatch.kt"); + } + + @Test + @TestMetadata("tryInsideTry.kt") + public void testTryInsideTry() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/tryInsideTry.kt"); + } + + @Test + @TestMetadata("unmatchedInlineMarkers.kt") + public void testUnmatchedInlineMarkers() throws Exception { + runTest("compiler/testData/codegen/box/controlStructures/tryCatchInExpressions/unmatchedInlineMarkers.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines") + @TestDataPath("$PROJECT_ROOT") + public class Coroutines { + @Test + @TestMetadata("32defaultParametersInSuspend.kt") + public void test32defaultParametersInSuspend() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/32defaultParametersInSuspend.kt"); + } + + @Test + @TestMetadata("accessorForSuspend.kt") + public void testAccessorForSuspend() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/accessorForSuspend.kt"); + } + + @Test + public void testAllFilesPresentInCoroutines() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("asyncIteratorNullMerge_1_3.kt") + public void testAsyncIteratorNullMerge_1_3() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/asyncIteratorNullMerge_1_3.kt"); + } + + @Test + @TestMetadata("asyncIteratorToList_1_3.kt") + public void testAsyncIteratorToList_1_3() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/asyncIteratorToList_1_3.kt"); + } + + @Test + @TestMetadata("asyncIterator_1_3.kt") + public void testAsyncIterator_1_3() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/asyncIterator_1_3.kt"); + } + + @Test + @TestMetadata("await.kt") + public void testAwait() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/await.kt"); + } + + @Test + @TestMetadata("beginWithException.kt") + public void testBeginWithException() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/beginWithException.kt"); + } + + @Test + @TestMetadata("beginWithExceptionNoHandleException.kt") + public void testBeginWithExceptionNoHandleException() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/beginWithExceptionNoHandleException.kt"); + } + + @Test + @TestMetadata("builderInferenceAndGenericArrayAcessCall.kt") + public void testBuilderInferenceAndGenericArrayAcessCall() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/builderInferenceAndGenericArrayAcessCall.kt"); + } + + @Test + @TestMetadata("captureInfixFun.kt") + public void testCaptureInfixFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/captureInfixFun.kt"); + } + + @Test + @TestMetadata("captureMutableLocalVariableInsideCoroutineBlock.kt") + public void testCaptureMutableLocalVariableInsideCoroutineBlock() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/captureMutableLocalVariableInsideCoroutineBlock.kt"); + } + + @Test + @TestMetadata("captureUnaryOperator.kt") + public void testCaptureUnaryOperator() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/captureUnaryOperator.kt"); + } + + @Test + @TestMetadata("capturedVarInSuspendLambda.kt") + public void testCapturedVarInSuspendLambda() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/capturedVarInSuspendLambda.kt"); + } + + @Test + @TestMetadata("castWithSuspend.kt") + public void testCastWithSuspend() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/castWithSuspend.kt"); + } + + @Test + @TestMetadata("catchWithInlineInsideSuspend.kt") + public void testCatchWithInlineInsideSuspend() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/catchWithInlineInsideSuspend.kt"); + } + + @Test + @TestMetadata("coercionToUnit.kt") + public void testCoercionToUnit() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/coercionToUnit.kt"); + } + + @Test + @TestMetadata("controllerAccessFromInnerLambda.kt") + public void testControllerAccessFromInnerLambda() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/controllerAccessFromInnerLambda.kt"); + } + + @Test + @TestMetadata("coroutineContextInInlinedLambda.kt") + public void testCoroutineContextInInlinedLambda() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/coroutineContextInInlinedLambda.kt"); + } + + @Test + @TestMetadata("createCoroutineSafe.kt") + public void testCreateCoroutineSafe() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/createCoroutineSafe.kt"); + } + + @Test + @TestMetadata("createCoroutinesOnManualInstances.kt") + public void testCreateCoroutinesOnManualInstances() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/createCoroutinesOnManualInstances.kt"); + } + + @Test + @TestMetadata("crossInlineWithCapturedOuterReceiver.kt") + public void testCrossInlineWithCapturedOuterReceiver() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/crossInlineWithCapturedOuterReceiver.kt"); + } + + @Test + @TestMetadata("defaultParameterLambdaInSuspend.kt") + public void testDefaultParameterLambdaInSuspend() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/defaultParameterLambdaInSuspend.kt"); + } + + @Test + @TestMetadata("defaultParametersInSuspend.kt") + public void testDefaultParametersInSuspend() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/defaultParametersInSuspend.kt"); + } + + @Test + @TestMetadata("delegatedSuspendMember.kt") + public void testDelegatedSuspendMember() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/delegatedSuspendMember.kt"); + } + + @Test + @TestMetadata("dispatchResume.kt") + public void testDispatchResume() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/dispatchResume.kt"); + } + + @Test + @TestMetadata("doubleColonExpressionsGenerationInBuilderInference.kt") + public void testDoubleColonExpressionsGenerationInBuilderInference() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/doubleColonExpressionsGenerationInBuilderInference.kt"); + } + + @Test + @TestMetadata("emptyClosure.kt") + public void testEmptyClosure() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/emptyClosure.kt"); + } + + @Test + @TestMetadata("emptyCommonConstraintSystemForCoroutineInferenceCall.kt") + public void testEmptyCommonConstraintSystemForCoroutineInferenceCall() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/emptyCommonConstraintSystemForCoroutineInferenceCall.kt"); + } + + @Test + @TestMetadata("epam.kt") + public void testEpam() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/epam.kt"); + } + + @Test + @TestMetadata("falseUnitCoercion.kt") + public void testFalseUnitCoercion() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/falseUnitCoercion.kt"); + } + + @Test + @TestMetadata("generate.kt") + public void testGenerate() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/generate.kt"); + } + + @Test + @TestMetadata("handleException.kt") + public void testHandleException() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/handleException.kt"); + } + + @Test + @TestMetadata("handleResultCallEmptyBody.kt") + public void testHandleResultCallEmptyBody() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/handleResultCallEmptyBody.kt"); + } + + @Test + @TestMetadata("handleResultNonUnitExpression.kt") + public void testHandleResultNonUnitExpression() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/handleResultNonUnitExpression.kt"); + } + + @Test + @TestMetadata("handleResultSuspended.kt") + public void testHandleResultSuspended() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/handleResultSuspended.kt"); + } + + @Test + @TestMetadata("indirectInlineUsedAsNonInline.kt") + public void testIndirectInlineUsedAsNonInline() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/indirectInlineUsedAsNonInline.kt"); + } + + @Test + @TestMetadata("infiniteLoopInNextMeaningful.kt") + public void testInfiniteLoopInNextMeaningful() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/infiniteLoopInNextMeaningful.kt"); + } + + @Test + @TestMetadata("inlineCallWithReturns.kt") + public void testInlineCallWithReturns() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineCallWithReturns.kt"); + } + + @Test + @TestMetadata("inlineFunInGenericClass.kt") + public void testInlineFunInGenericClass() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineFunInGenericClass.kt"); + } + + @Test + @TestMetadata("inlineGenericFunCalledFromSubclass.kt") + public void testInlineGenericFunCalledFromSubclass() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineGenericFunCalledFromSubclass.kt"); + } + + @Test + @TestMetadata("inlineSuspendFunction.kt") + public void testInlineSuspendFunction() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineSuspendFunction.kt"); + } + + @Test + @TestMetadata("inlineSuspendLambdaNonLocalReturn.kt") + public void testInlineSuspendLambdaNonLocalReturn() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineSuspendLambdaNonLocalReturn.kt"); + } + + @Test + @TestMetadata("inlineSuspendTypealias.kt") + public void testInlineSuspendTypealias() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineSuspendTypealias.kt"); + } + + @Test + @TestMetadata("inlinedTryCatchFinally.kt") + public void testInlinedTryCatchFinally() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlinedTryCatchFinally.kt"); + } + + @Test + @TestMetadata("innerSuspensionCalls.kt") + public void testInnerSuspensionCalls() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/innerSuspensionCalls.kt"); + } + + @Test + @TestMetadata("instanceOfContinuation.kt") + public void testInstanceOfContinuation() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/instanceOfContinuation.kt"); + } + + @Test + @TestMetadata("iterateOverArray.kt") + public void testIterateOverArray() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/iterateOverArray.kt"); + } + + @Test + @TestMetadata("kt12958.kt") + public void testKt12958() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt12958.kt"); + } + + @Test + @TestMetadata("kt15016.kt") + public void testKt15016() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt15016.kt"); + } + + @Test + @TestMetadata("kt15017.kt") + public void testKt15017() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt15017.kt"); + } + + @Test + @TestMetadata("kt15930.kt") + public void testKt15930() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt15930.kt"); + } + + @Test + @TestMetadata("kt21080.kt") + public void testKt21080() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt21080.kt"); + } + + @Test + @TestMetadata("kt21605.kt") + public void testKt21605() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt21605.kt"); + } + + @Test + @TestMetadata("kt24135.kt") + public void testKt24135() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt24135.kt"); + } + + @Test + @TestMetadata("kt25912.kt") + public void testKt25912() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt25912.kt"); + } + + @Test + @TestMetadata("kt28844.kt") + public void testKt28844() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt28844.kt"); + } + + @Test + @TestMetadata("kt30858.kt") + public void testKt30858() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt30858.kt"); + } + + @Test + @TestMetadata("kt31784.kt") + public void testKt31784() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt31784.kt"); + } + + @Test + @TestMetadata("kt35967.kt") + public void testKt35967() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt35967.kt"); + } + + @Test + @TestMetadata("kt42028.kt") + public void testKt42028() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt42028.kt"); + } + + @Test + @TestMetadata("kt42554.kt") + public void testKt42554() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt42554.kt"); + } + + @Test + @TestMetadata("kt44221.kt") + public void testKt44221() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt44221.kt"); + } + + @Test + @TestMetadata("kt44710.kt") + public void testKt44710() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt44710.kt"); + } + + @Test + @TestMetadata("kt44781.kt") + public void testKt44781() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt44781.kt"); + } + + @Test + @TestMetadata("kt45377.kt") + public void testKt45377() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt45377.kt"); + } + + @Test + @TestMetadata("kt46813.kt") + public void testKt46813() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt46813.kt"); + } + + @Test + @TestMetadata("kt49168.kt") + public void testKt49168() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt49168.kt"); + } + + @Test + @TestMetadata("kt49317.kt") + public void testKt49317() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt49317.kt"); + } + + @Test + @TestMetadata("kt51530.kt") + public void testKt51530() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt51530.kt"); + } + + @Test + @TestMetadata("kt51718.kt") + public void testKt51718() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt51718.kt"); + } + + @Test + @TestMetadata("kt52311_nullOnLeft.kt") + public void testKt52311_nullOnLeft() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt52311_nullOnLeft.kt"); + } + + @Test + @TestMetadata("kt52311_nullOnRight.kt") + public void testKt52311_nullOnRight() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt52311_nullOnRight.kt"); + } + + @Test + @TestMetadata("kt52561.kt") + public void testKt52561() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt52561.kt"); + } + + @Test + @TestMetadata("kt55494.kt") + public void testKt55494() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt55494.kt"); + } + + @Test + @TestMetadata("kt56407.kt") + public void testKt56407() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/kt56407.kt"); + } + + @Test + @TestMetadata("lastExpressionIsLoop.kt") + public void testLastExpressionIsLoop() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/lastExpressionIsLoop.kt"); + } + + @Test + @TestMetadata("lastStatementInc.kt") + public void testLastStatementInc() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/lastStatementInc.kt"); + } + + @Test + @TestMetadata("lastStementAssignment.kt") + public void testLastStementAssignment() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/lastStementAssignment.kt"); + } + + @Test + @TestMetadata("lastUnitExpression.kt") + public void testLastUnitExpression() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/lastUnitExpression.kt"); + } + + @Test + @TestMetadata("localCallableRef.kt") + public void testLocalCallableRef() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/localCallableRef.kt"); + } + + @Test + @TestMetadata("localDelegate.kt") + public void testLocalDelegate() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/localDelegate.kt"); + } + + @Test + @TestMetadata("longRangeInSuspendCall.kt") + public void testLongRangeInSuspendCall() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/longRangeInSuspendCall.kt"); + } + + @Test + @TestMetadata("longRangeInSuspendFun.kt") + public void testLongRangeInSuspendFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/longRangeInSuspendFun.kt"); + } + + @Test + @TestMetadata("mergeNullAndString.kt") + public void testMergeNullAndString() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/mergeNullAndString.kt"); + } + + @Test + @TestMetadata("multipleInvokeCalls.kt") + public void testMultipleInvokeCalls() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/multipleInvokeCalls.kt"); + } + + @Test + @TestMetadata("multipleInvokeCallsInsideInlineLambda1.kt") + public void testMultipleInvokeCallsInsideInlineLambda1() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/multipleInvokeCallsInsideInlineLambda1.kt"); + } + + @Test + @TestMetadata("multipleInvokeCallsInsideInlineLambda2.kt") + public void testMultipleInvokeCallsInsideInlineLambda2() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/multipleInvokeCallsInsideInlineLambda2.kt"); + } + + @Test + @TestMetadata("multipleInvokeCallsInsideInlineLambda3.kt") + public void testMultipleInvokeCallsInsideInlineLambda3() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/multipleInvokeCallsInsideInlineLambda3.kt"); + } + + @Test + @TestMetadata("nestedTryCatch.kt") + public void testNestedTryCatch() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/nestedTryCatch.kt"); + } + + @Test + @TestMetadata("noSuspensionPoints.kt") + public void testNoSuspensionPoints() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/noSuspensionPoints.kt"); + } + + @Test + @TestMetadata("nonLocalReturn.kt") + public void testNonLocalReturn() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/nonLocalReturn.kt"); + } + + @Test + @TestMetadata("nonLocalReturnFromInlineLambda.kt") + public void testNonLocalReturnFromInlineLambda() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/nonLocalReturnFromInlineLambda.kt"); + } + + @Test + @TestMetadata("nonLocalReturnFromInlineLambdaDeep.kt") + public void testNonLocalReturnFromInlineLambdaDeep() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/nonLocalReturnFromInlineLambdaDeep.kt"); + } + + @Test + @TestMetadata("nullableSuspendFunctionType.kt") + public void testNullableSuspendFunctionType() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/nullableSuspendFunctionType.kt"); + } + + @Test + @TestMetadata("overrideDefaultArgument.kt") + public void testOverrideDefaultArgument() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/overrideDefaultArgument.kt"); + } + + @Test + @TestMetadata("recursiveSuspend.kt") + public void testRecursiveSuspend() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/recursiveSuspend.kt"); + } + + @Test + @TestMetadata("returnByLabel.kt") + public void testReturnByLabel() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/returnByLabel.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/simple.kt"); + } + + @Test + @TestMetadata("simpleException.kt") + public void testSimpleException() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/simpleException.kt"); + } + + @Test + @TestMetadata("simpleSuspendCallableReference.kt") + public void testSimpleSuspendCallableReference() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/simpleSuspendCallableReference.kt"); + } + + @Test + @TestMetadata("simpleWithDefaultValue.kt") + public void testSimpleWithDefaultValue() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/simpleWithDefaultValue.kt"); + } + + @Test + @TestMetadata("simpleWithHandleResult.kt") + public void testSimpleWithHandleResult() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/simpleWithHandleResult.kt"); + } + + @Test + @TestMetadata("statementLikeLastExpression.kt") + public void testStatementLikeLastExpression() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/statementLikeLastExpression.kt"); + } + + @Test + @TestMetadata("stopAfter.kt") + public void testStopAfter() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/stopAfter.kt"); + } + + @Test + @TestMetadata("suspendCallsInArguments.kt") + public void testSuspendCallsInArguments() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendCallsInArguments.kt"); + } + + @Test + @TestMetadata("suspendCoroutineFromStateMachine.kt") + public void testSuspendCoroutineFromStateMachine() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendCoroutineFromStateMachine.kt"); + } + + @Test + @TestMetadata("suspendDefaultImpl.kt") + public void testSuspendDefaultImpl() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendDefaultImpl.kt"); + } + + @Test + @TestMetadata("suspendDelegation.kt") + public void testSuspendDelegation() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendDelegation.kt"); + } + + @Test + @TestMetadata("suspendFromInlineLambda.kt") + public void testSuspendFromInlineLambda() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFromInlineLambda.kt"); + } + + @Test + @TestMetadata("suspendFunImportedFromObject.kt") + public void testSuspendFunImportedFromObject() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunImportedFromObject.kt"); + } + + @Test + @TestMetadata("suspendFunctionAsSupertype.kt") + public void testSuspendFunctionAsSupertype() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsSupertype.kt"); + } + + @Test + @TestMetadata("suspendFunctionAsSupertypeCall.kt") + public void testSuspendFunctionAsSupertypeCall() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsSupertypeCall.kt"); + } + + @Test + @TestMetadata("suspendFunctionMethodReference.kt") + public void testSuspendFunctionMethodReference() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunctionMethodReference.kt"); + } + + @Test + @TestMetadata("suspendInCycle.kt") + public void testSuspendInCycle() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendInCycle.kt"); + } + + @Test + @TestMetadata("suspendInTheMiddleOfObjectConstruction.kt") + public void testSuspendInTheMiddleOfObjectConstruction() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendInTheMiddleOfObjectConstruction.kt"); + } + + @Test + @TestMetadata("suspendInTheMiddleOfObjectConstructionEvaluationOrder.kt") + public void testSuspendInTheMiddleOfObjectConstructionEvaluationOrder() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendInTheMiddleOfObjectConstructionEvaluationOrder.kt"); + } + + @Test + @TestMetadata("suspendInTheMiddleOfObjectConstructionWithJumpOut.kt") + public void testSuspendInTheMiddleOfObjectConstructionWithJumpOut() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendInTheMiddleOfObjectConstructionWithJumpOut.kt"); + } + + @Test + @TestMetadata("suspendInlineReference.kt") + public void testSuspendInlineReference() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendInlineReference.kt"); + } + + @Test + @TestMetadata("suspendLambdaInInterface.kt") + public void testSuspendLambdaInInterface() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendLambdaInInterface.kt"); + } + + @Test + @TestMetadata("suspendLambdaWithArgumentRearrangement.kt") + public void testSuspendLambdaWithArgumentRearrangement() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendLambdaWithArgumentRearrangement.kt"); + } + + @Test + @TestMetadata("suspensionInsideSafeCall.kt") + public void testSuspensionInsideSafeCall() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspensionInsideSafeCall.kt"); + } + + @Test + @TestMetadata("suspensionInsideSafeCallWithElvis.kt") + public void testSuspensionInsideSafeCallWithElvis() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspensionInsideSafeCallWithElvis.kt"); + } + + @Test + @TestMetadata("tailCallToNothing.kt") + public void testTailCallToNothing() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallToNothing.kt"); + } + + @Test + @TestMetadata("tryCatchFinallyWithHandleResult.kt") + public void testTryCatchFinallyWithHandleResult() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tryCatchFinallyWithHandleResult.kt"); + } + + @Test + @TestMetadata("tryCatchWithHandleResult.kt") + public void testTryCatchWithHandleResult() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tryCatchWithHandleResult.kt"); + } + + @Test + @TestMetadata("tryFinallyInsideInlineLambda.kt") + public void testTryFinallyInsideInlineLambda() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tryFinallyInsideInlineLambda.kt"); + } + + @Test + @TestMetadata("tryFinallyWithHandleResult.kt") + public void testTryFinallyWithHandleResult() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tryFinallyWithHandleResult.kt"); + } + + @Test + @TestMetadata("varCaptuedInCoroutineIntrinsic.kt") + public void testVarCaptuedInCoroutineIntrinsic() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/varCaptuedInCoroutineIntrinsic.kt"); + } + + @Test + @TestMetadata("varValueConflictsWithTable.kt") + public void testVarValueConflictsWithTable() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/varValueConflictsWithTable.kt"); + } + + @Test + @TestMetadata("varValueConflictsWithTableSameSort.kt") + public void testVarValueConflictsWithTableSameSort() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/varValueConflictsWithTableSameSort.kt"); + } + + @Test + @TestMetadata("varargCallFromSuspend.kt") + public void testVarargCallFromSuspend() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/varargCallFromSuspend.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/bridges") + @TestDataPath("$PROJECT_ROOT") + public class Bridges { + @Test + public void testAllFilesPresentInBridges() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/bridges"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("interfaceGenericDefault.kt") + public void testInterfaceGenericDefault() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/bridges/interfaceGenericDefault.kt"); + } + + @Test + @TestMetadata("interfaceSpecialization.kt") + public void testInterfaceSpecialization() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/bridges/interfaceSpecialization.kt"); + } + + @Test + @TestMetadata("lambdaWithLongReceiver.kt") + public void testLambdaWithLongReceiver() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/bridges/lambdaWithLongReceiver.kt"); + } + + @Test + @TestMetadata("lambdaWithMultipleParameters.kt") + public void testLambdaWithMultipleParameters() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/bridges/lambdaWithMultipleParameters.kt"); + } + + @Test + @TestMetadata("mapSuspendAbstractClear.kt") + public void testMapSuspendAbstractClear() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/bridges/mapSuspendAbstractClear.kt"); + } + + @Test + @TestMetadata("mapSuspendClear.kt") + public void testMapSuspendClear() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/bridges/mapSuspendClear.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/controlFlow") + @TestDataPath("$PROJECT_ROOT") + public class ControlFlow { + @Test + public void testAllFilesPresentInControlFlow() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/controlFlow"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("breakFinally.kt") + public void testBreakFinally() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/controlFlow/breakFinally.kt"); + } + + @Test + @TestMetadata("breakStatement.kt") + public void testBreakStatement() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/controlFlow/breakStatement.kt"); + } + + @Test + @TestMetadata("complexChainSuspend.kt") + public void testComplexChainSuspend() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/controlFlow/complexChainSuspend.kt"); + } + + @Test + @TestMetadata("doWhileStatement.kt") + public void testDoWhileStatement() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/controlFlow/doWhileStatement.kt"); + } + + @Test + @TestMetadata("doWhileWithInline.kt") + public void testDoWhileWithInline() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/controlFlow/doWhileWithInline.kt"); + } + + @Test + @TestMetadata("doubleBreak.kt") + public void testDoubleBreak() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/controlFlow/doubleBreak.kt"); + } + + @Test + @TestMetadata("finallyCatch.kt") + public void testFinallyCatch() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/controlFlow/finallyCatch.kt"); + } + + @Test + @TestMetadata("forContinue.kt") + public void testForContinue() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/controlFlow/forContinue.kt"); + } + + @Test + @TestMetadata("forStatement.kt") + public void testForStatement() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/controlFlow/forStatement.kt"); + } + + @Test + @TestMetadata("forWithStep.kt") + public void testForWithStep() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/controlFlow/forWithStep.kt"); + } + + @Test + @TestMetadata("ifStatement.kt") + public void testIfStatement() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/controlFlow/ifStatement.kt"); + } + + @Test + @TestMetadata("kt22694_1_3.kt") + public void testKt22694_1_3() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/controlFlow/kt22694_1_3.kt"); + } + + @Test + @TestMetadata("labeledWhile.kt") + public void testLabeledWhile() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/controlFlow/labeledWhile.kt"); + } + + @Test + @TestMetadata("multipleCatchBlocksSuspend.kt") + public void testMultipleCatchBlocksSuspend() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/controlFlow/multipleCatchBlocksSuspend.kt"); + } + + @Test + @TestMetadata("returnFromFinally.kt") + public void testReturnFromFinally() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/controlFlow/returnFromFinally.kt"); + } + + @Test + @TestMetadata("returnWithFinally.kt") + public void testReturnWithFinally() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/controlFlow/returnWithFinally.kt"); + } + + @Test + @TestMetadata("suspendInStringTemplate.kt") + public void testSuspendInStringTemplate() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/controlFlow/suspendInStringTemplate.kt"); + } + + @Test + @TestMetadata("switchLikeWhen.kt") + public void testSwitchLikeWhen() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/controlFlow/switchLikeWhen.kt"); + } + + @Test + @TestMetadata("throwFromCatch.kt") + public void testThrowFromCatch() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/controlFlow/throwFromCatch.kt"); + } + + @Test + @TestMetadata("throwFromFinally.kt") + public void testThrowFromFinally() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/controlFlow/throwFromFinally.kt"); + } + + @Test + @TestMetadata("throwInTryWithHandleResult.kt") + public void testThrowInTryWithHandleResult() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/controlFlow/throwInTryWithHandleResult.kt"); + } + + @Test + @TestMetadata("whenWithSuspensions.kt") + public void testWhenWithSuspensions() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/controlFlow/whenWithSuspensions.kt"); + } + + @Test + @TestMetadata("whileStatement.kt") + public void testWhileStatement() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/controlFlow/whileStatement.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/debug") + @TestDataPath("$PROJECT_ROOT") + public class Debug { + @Test + public void testAllFilesPresentInDebug() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/debug"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/featureIntersection") + @TestDataPath("$PROJECT_ROOT") + public class FeatureIntersection { + @Test + public void testAllFilesPresentInFeatureIntersection() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("breakWithNonEmptyStack.kt") + public void testBreakWithNonEmptyStack() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/breakWithNonEmptyStack.kt"); + } + + @Test + @TestMetadata("defaultExpect.kt") + public void testDefaultExpect() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/defaultExpect.kt"); + } + + @Test + @TestMetadata("delegate.kt") + public void testDelegate() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/delegate.kt"); + } + + @Test + @TestMetadata("destructuringInLambdas.kt") + public void testDestructuringInLambdas() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/destructuringInLambdas.kt"); + } + + @Test + @TestMetadata("funInterface.kt") + public void testFunInterface() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/funInterface.kt"); + } + + @Test + @TestMetadata("inlineSuspendFinally.kt") + public void testInlineSuspendFinally() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/inlineSuspendFinally.kt"); + } + + @Test + @TestMetadata("interfaceMethodWithBody.kt") + public void testInterfaceMethodWithBody() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/interfaceMethodWithBody.kt"); + } + + @Test + @TestMetadata("interfaceMethodWithBodyGeneric.kt") + public void testInterfaceMethodWithBodyGeneric() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/interfaceMethodWithBodyGeneric.kt"); + } + + @Test + @TestMetadata("overrideInInlineClass.kt") + public void testOverrideInInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/overrideInInlineClass.kt"); + } + + @Test + @TestMetadata("overrideInInnerClass.kt") + public void testOverrideInInnerClass() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/overrideInInnerClass.kt"); + } + + @Test + @TestMetadata("safeCallOnTwoReceivers.kt") + public void testSafeCallOnTwoReceivers() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/safeCallOnTwoReceivers.kt"); + } + + @Test + @TestMetadata("safeCallOnTwoReceiversLong.kt") + public void testSafeCallOnTwoReceiversLong() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/safeCallOnTwoReceiversLong.kt"); + } + + @Test + @TestMetadata("suspendDestructuringInLambdas.kt") + public void testSuspendDestructuringInLambdas() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/suspendDestructuringInLambdas.kt"); + } + + @Test + @TestMetadata("suspendFunctionAsSupertypeIsCheckWithArity.kt") + public void testSuspendFunctionAsSupertypeIsCheckWithArity() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/suspendFunctionAsSupertypeIsCheckWithArity.kt"); + } + + @Test + @TestMetadata("suspendFunctionIsAs.kt") + public void testSuspendFunctionIsAs() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/suspendFunctionIsAs.kt"); + } + + @Test + @TestMetadata("suspendInlineSuspendFinally.kt") + public void testSuspendInlineSuspendFinally() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/suspendInlineSuspendFinally.kt"); + } + + @Test + @TestMetadata("suspendOperatorPlus.kt") + public void testSuspendOperatorPlus() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/suspendOperatorPlus.kt"); + } + + @Test + @TestMetadata("suspendOperatorPlusAssign.kt") + public void testSuspendOperatorPlusAssign() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/suspendOperatorPlusAssign.kt"); + } + + @Test + @TestMetadata("suspendOperatorPlusCallFromLambda.kt") + public void testSuspendOperatorPlusCallFromLambda() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/suspendOperatorPlusCallFromLambda.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference") + @TestDataPath("$PROJECT_ROOT") + public class CallableReference { + @Test + public void testAllFilesPresentInCallableReference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("bigArity.kt") + public void testBigArity() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/bigArity.kt"); + } + + @Test + @TestMetadata("lambdaParameterUsed.kt") + public void testLambdaParameterUsed() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/lambdaParameterUsed.kt"); + } + + @Test + @TestMetadata("longArgs.kt") + public void testLongArgs() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/longArgs.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/bound") + @TestDataPath("$PROJECT_ROOT") + public class Bound { + @Test + public void testAllFilesPresentInBound() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/bound"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("emptyLHS.kt") + public void testEmptyLHS() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/bound/emptyLHS.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function") + @TestDataPath("$PROJECT_ROOT") + public class Function { + @Test + @TestMetadata("adapted.kt") + public void testAdapted() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/adapted.kt"); + } + + @Test + public void testAllFilesPresentInFunction() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("genericCallableReferencesWithNullableTypes.kt") + public void testGenericCallableReferencesWithNullableTypes() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/genericCallableReferencesWithNullableTypes.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/local") + @TestDataPath("$PROJECT_ROOT") + public class Local { + @Test + public void testAllFilesPresentInLocal() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/local"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("equalsHashCode.kt") + public void testEqualsHashCode() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/local/equalsHashCode.kt"); + } + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/featureIntersection/funInterface") + @TestDataPath("$PROJECT_ROOT") + public class FunInterface { + @Test + public void testAllFilesPresentInFunInterface() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/funInterface"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt47549.kt") + public void testKt47549() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/funInterface/kt47549.kt"); + } + + @Test + @TestMetadata("kt47549_1.kt") + public void testKt47549_1() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/funInterface/kt47549_1.kt"); + } + + @Test + @TestMetadata("kt49294.kt") + public void testKt49294() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/funInterface/kt49294.kt"); + } + + @Test + @TestMetadata("kt50950.kt") + public void testKt50950() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/funInterface/kt50950.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/featureIntersection/jvmDefault") + @TestDataPath("$PROJECT_ROOT") + public class JvmDefault { + @Test + public void testAllFilesPresentInJvmDefault() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/jvmDefault"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/featureIntersection/jvmDefault/kt46007") + @TestDataPath("$PROJECT_ROOT") + public class Kt46007 { + @Test + public void testAllFilesPresentInKt46007() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/jvmDefault/kt46007"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec") + @TestDataPath("$PROJECT_ROOT") + public class Tailrec { + @Test + public void testAllFilesPresentInTailrec() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("controlFlowIf.kt") + public void testControlFlowIf() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/controlFlowIf.kt"); + } + + @Test + @TestMetadata("controlFlowWhen.kt") + public void testControlFlowWhen() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/controlFlowWhen.kt"); + } + + @Test + @TestMetadata("extention.kt") + public void testExtention() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/extention.kt"); + } + + @Test + @TestMetadata("infixCall.kt") + public void testInfixCall() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/infixCall.kt"); + } + + @Test + @TestMetadata("infixRecursiveCall.kt") + public void testInfixRecursiveCall() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/infixRecursiveCall.kt"); + } + + @Test + @TestMetadata("kt38920_localTailrec.kt") + public void testKt38920_localTailrec() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/kt38920_localTailrec.kt"); + } + + @Test + @TestMetadata("realIteratorFoldl.kt") + public void testRealIteratorFoldl() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/realIteratorFoldl.kt"); + } + + @Test + @TestMetadata("realStringEscape.kt") + public void testRealStringEscape() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/realStringEscape.kt"); + } + + @Test + @TestMetadata("realStringRepeat.kt") + public void testRealStringRepeat() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/realStringRepeat.kt"); + } + + @Test + @TestMetadata("returnInParentheses.kt") + public void testReturnInParentheses() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/returnInParentheses.kt"); + } + + @Test + @TestMetadata("sum.kt") + public void testSum() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/sum.kt"); + } + + @Test + @TestMetadata("tailCallInBlockInParentheses.kt") + public void testTailCallInBlockInParentheses() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/tailCallInBlockInParentheses.kt"); + } + + @Test + @TestMetadata("tailCallInParentheses.kt") + public void testTailCallInParentheses() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/tailCallInParentheses.kt"); + } + + @Test + @TestMetadata("whenWithIs.kt") + public void testWhenWithIs() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/featureIntersection/tailrec/whenWithIs.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/inlineClasses") + @TestDataPath("$PROJECT_ROOT") + public class InlineClasses { + @Test + public void testAllFilesPresentInInlineClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("genericParameterResult.kt") + public void testGenericParameterResult() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/genericParameterResult.kt"); + } + + @Test + @TestMetadata("kt47129.kt") + public void testKt47129() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/kt47129.kt"); + } + + @Test + @TestMetadata("nonLocalReturn.kt") + public void testNonLocalReturn() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/nonLocalReturn.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/inlineClasses/direct") + @TestDataPath("$PROJECT_ROOT") + public class Direct { + @Test + public void testAllFilesPresentInDirect() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/direct"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") + public void testBoxReturnValueOfSuspendFunctionReference() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxReturnValueOfSuspendFunctionReference.kt"); + } + + @Test + @TestMetadata("boxReturnValueOfSuspendLambda.kt") + public void testBoxReturnValueOfSuspendLambda() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxReturnValueOfSuspendLambda.kt"); + } + + @Test + @TestMetadata("boxTypeParameterOfSuperType.kt") + public void testBoxTypeParameterOfSuperType() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxTypeParameterOfSuperType.kt"); + } + + @Test + @TestMetadata("boxTypeParameterOfSuperTypeResult.kt") + public void testBoxTypeParameterOfSuperTypeResult() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxTypeParameterOfSuperTypeResult.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine.kt") + public void testBoxUnboxInsideCoroutine() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxUnboxInsideCoroutine.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine_Any.kt") + public void testBoxUnboxInsideCoroutine_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxUnboxInsideCoroutine_Any.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine_InlineAny.kt") + public void testBoxUnboxInsideCoroutine_InlineAny() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxUnboxInsideCoroutine_InlineAny.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine_InlineInt.kt") + public void testBoxUnboxInsideCoroutine_InlineInt() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxUnboxInsideCoroutine_InlineInt.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine_Int.kt") + public void testBoxUnboxInsideCoroutine_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxUnboxInsideCoroutine_Int.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine_Long.kt") + public void testBoxUnboxInsideCoroutine_Long() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxUnboxInsideCoroutine_Long.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine_NAny.kt") + public void testBoxUnboxInsideCoroutine_NAny() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxUnboxInsideCoroutine_NAny.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine_nonLocalReturn.kt") + public void testBoxUnboxInsideCoroutine_nonLocalReturn() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxUnboxInsideCoroutine_nonLocalReturn.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine_suspendFunType.kt") + public void testBoxUnboxInsideCoroutine_suspendFunType() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/boxUnboxInsideCoroutine_suspendFunType.kt"); + } + + @Test + @TestMetadata("bridgeGenerationCrossinline.kt") + public void testBridgeGenerationCrossinline() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/bridgeGenerationCrossinline.kt"); + } + + @Test + @TestMetadata("bridgeGenerationNonInline.kt") + public void testBridgeGenerationNonInline() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/bridgeGenerationNonInline.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFun.kt") + public void testCovariantOverrideSuspendFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFun.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunSameJvmType.kt") + public void testCovariantOverrideSuspendFunSameJvmType() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFunSameJvmType.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFunWithNullableInlineClass.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClassSameJvmType.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClassSameJvmType() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFunWithNullableInlineClassSameJvmType.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_Any.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFunWithNullableInlineClass_Any.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_Int.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFunWithNullableInlineClass_Int.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableAny() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableInt() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFun_Any.kt") + public void testCovariantOverrideSuspendFun_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFun_Any.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFun_Int.kt") + public void testCovariantOverrideSuspendFun_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/covariantOverrideSuspendFun_Int.kt"); + } + + @Test + @TestMetadata("createMangling.kt") + public void testCreateMangling() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/createMangling.kt"); + } + + @Test + @TestMetadata("createOverride.kt") + public void testCreateOverride() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/createOverride.kt"); + } + + @Test + @TestMetadata("defaultStub.kt") + public void testDefaultStub() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/defaultStub.kt"); + } + + @Test + @TestMetadata("genericOverrideSuspendFun.kt") + public void testGenericOverrideSuspendFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/genericOverrideSuspendFun.kt"); + } + + @Test + @TestMetadata("genericOverrideSuspendFun_Any.kt") + public void testGenericOverrideSuspendFun_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/genericOverrideSuspendFun_Any.kt"); + } + + @Test + @TestMetadata("genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt") + public void testGenericOverrideSuspendFun_Any_NullableInlineClassUpperBound() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt"); + } + + @Test + @TestMetadata("genericOverrideSuspendFun_Int.kt") + public void testGenericOverrideSuspendFun_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/genericOverrideSuspendFun_Int.kt"); + } + + @Test + @TestMetadata("genericOverrideSuspendFun_NullableAny.kt") + public void testGenericOverrideSuspendFun_NullableAny() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/genericOverrideSuspendFun_NullableAny.kt"); + } + + @Test + @TestMetadata("genericOverrideSuspendFun_NullableAny_null.kt") + public void testGenericOverrideSuspendFun_NullableAny_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/genericOverrideSuspendFun_NullableAny_null.kt"); + } + + @Test + @TestMetadata("genericOverrideSuspendFun_NullableInt.kt") + public void testGenericOverrideSuspendFun_NullableInt() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/genericOverrideSuspendFun_NullableInt.kt"); + } + + @Test + @TestMetadata("genericOverrideSuspendFun_NullableInt_null.kt") + public void testGenericOverrideSuspendFun_NullableInt_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/genericOverrideSuspendFun_NullableInt_null.kt"); + } + + @Test + @TestMetadata("interfaceDelegateWithInlineClass.kt") + public void testInterfaceDelegateWithInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/interfaceDelegateWithInlineClass.kt"); + } + + @Test + @TestMetadata("invokeOperator.kt") + public void testInvokeOperator() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/invokeOperator.kt"); + } + + @Test + @TestMetadata("overrideSuspendFun.kt") + public void testOverrideSuspendFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/overrideSuspendFun.kt"); + } + + @Test + @TestMetadata("overrideSuspendFun_Any.kt") + public void testOverrideSuspendFun_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/overrideSuspendFun_Any.kt"); + } + + @Test + @TestMetadata("overrideSuspendFun_Any_itf.kt") + public void testOverrideSuspendFun_Any_itf() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/overrideSuspendFun_Any_itf.kt"); + } + + @Test + @TestMetadata("overrideSuspendFun_Any_this.kt") + public void testOverrideSuspendFun_Any_this() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/overrideSuspendFun_Any_this.kt"); + } + + @Test + @TestMetadata("overrideSuspendFun_Int.kt") + public void testOverrideSuspendFun_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/overrideSuspendFun_Int.kt"); + } + + @Test + @TestMetadata("returnResult.kt") + public void testReturnResult() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/returnResult.kt"); + } + + @Test + @TestMetadata("syntheticAccessor.kt") + public void testSyntheticAccessor() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/direct/syntheticAccessor.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/inlineClasses/resume") + @TestDataPath("$PROJECT_ROOT") + public class Resume { + @Test + public void testAllFilesPresentInResume() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resume"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") + public void testBoxReturnValueOfSuspendFunctionReference() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxReturnValueOfSuspendFunctionReference.kt"); + } + + @Test + @TestMetadata("boxReturnValueOfSuspendLambda.kt") + public void testBoxReturnValueOfSuspendLambda() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxReturnValueOfSuspendLambda.kt"); + } + + @Test + @TestMetadata("boxTypeParameterOfSuperType.kt") + public void testBoxTypeParameterOfSuperType() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxTypeParameterOfSuperType.kt"); + } + + @Test + @TestMetadata("boxTypeParameterOfSuperTypeResult.kt") + public void testBoxTypeParameterOfSuperTypeResult() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxTypeParameterOfSuperTypeResult.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine.kt") + public void testBoxUnboxInsideCoroutine() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxUnboxInsideCoroutine.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine_Any.kt") + public void testBoxUnboxInsideCoroutine_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxUnboxInsideCoroutine_Any.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine_InlineAny.kt") + public void testBoxUnboxInsideCoroutine_InlineAny() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxUnboxInsideCoroutine_InlineAny.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine_InlineInt.kt") + public void testBoxUnboxInsideCoroutine_InlineInt() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxUnboxInsideCoroutine_InlineInt.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine_Int.kt") + public void testBoxUnboxInsideCoroutine_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxUnboxInsideCoroutine_Int.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine_Long.kt") + public void testBoxUnboxInsideCoroutine_Long() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxUnboxInsideCoroutine_Long.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine_NAny.kt") + public void testBoxUnboxInsideCoroutine_NAny() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxUnboxInsideCoroutine_NAny.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine_nonLocalReturn.kt") + public void testBoxUnboxInsideCoroutine_nonLocalReturn() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxUnboxInsideCoroutine_nonLocalReturn.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine_suspendFunType.kt") + public void testBoxUnboxInsideCoroutine_suspendFunType() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/boxUnboxInsideCoroutine_suspendFunType.kt"); + } + + @Test + @TestMetadata("bridgeGenerationCrossinline.kt") + public void testBridgeGenerationCrossinline() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/bridgeGenerationCrossinline.kt"); + } + + @Test + @TestMetadata("bridgeGenerationNonInline.kt") + public void testBridgeGenerationNonInline() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/bridgeGenerationNonInline.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFun.kt") + public void testCovariantOverrideSuspendFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFun.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunSameJvmType.kt") + public void testCovariantOverrideSuspendFunSameJvmType() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFunSameJvmType.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFunWithNullableInlineClass.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClassSameJvmType.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClassSameJvmType() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFunWithNullableInlineClassSameJvmType.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_Any.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFunWithNullableInlineClass_Any.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_Int.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFunWithNullableInlineClass_Int.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableAny() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableInt() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt_null.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFun_Any.kt") + public void testCovariantOverrideSuspendFun_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFun_Any.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFun_Int.kt") + public void testCovariantOverrideSuspendFun_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/covariantOverrideSuspendFun_Int.kt"); + } + + @Test + @TestMetadata("createMangling.kt") + public void testCreateMangling() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/createMangling.kt"); + } + + @Test + @TestMetadata("createOverride.kt") + public void testCreateOverride() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/createOverride.kt"); + } + + @Test + @TestMetadata("defaultStub.kt") + public void testDefaultStub() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/defaultStub.kt"); + } + + @Test + @TestMetadata("genericOverrideSuspendFun.kt") + public void testGenericOverrideSuspendFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/genericOverrideSuspendFun.kt"); + } + + @Test + @TestMetadata("genericOverrideSuspendFun_Any.kt") + public void testGenericOverrideSuspendFun_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/genericOverrideSuspendFun_Any.kt"); + } + + @Test + @TestMetadata("genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt") + public void testGenericOverrideSuspendFun_Any_NullableInlineClassUpperBound() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt"); + } + + @Test + @TestMetadata("genericOverrideSuspendFun_Int.kt") + public void testGenericOverrideSuspendFun_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/genericOverrideSuspendFun_Int.kt"); + } + + @Test + @TestMetadata("genericOverrideSuspendFun_NullableAny.kt") + public void testGenericOverrideSuspendFun_NullableAny() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/genericOverrideSuspendFun_NullableAny.kt"); + } + + @Test + @TestMetadata("genericOverrideSuspendFun_NullableAny_null.kt") + public void testGenericOverrideSuspendFun_NullableAny_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/genericOverrideSuspendFun_NullableAny_null.kt"); + } + + @Test + @TestMetadata("genericOverrideSuspendFun_NullableInt.kt") + public void testGenericOverrideSuspendFun_NullableInt() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/genericOverrideSuspendFun_NullableInt.kt"); + } + + @Test + @TestMetadata("genericOverrideSuspendFun_NullableInt_null.kt") + public void testGenericOverrideSuspendFun_NullableInt_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/genericOverrideSuspendFun_NullableInt_null.kt"); + } + + @Test + @TestMetadata("interfaceDelegateWithInlineClass.kt") + public void testInterfaceDelegateWithInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/interfaceDelegateWithInlineClass.kt"); + } + + @Test + @TestMetadata("invokeOperator.kt") + public void testInvokeOperator() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/invokeOperator.kt"); + } + + @Test + @TestMetadata("overrideSuspendFun.kt") + public void testOverrideSuspendFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/overrideSuspendFun.kt"); + } + + @Test + @TestMetadata("overrideSuspendFun_Any.kt") + public void testOverrideSuspendFun_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/overrideSuspendFun_Any.kt"); + } + + @Test + @TestMetadata("overrideSuspendFun_Any_itf.kt") + public void testOverrideSuspendFun_Any_itf() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/overrideSuspendFun_Any_itf.kt"); + } + + @Test + @TestMetadata("overrideSuspendFun_Any_this.kt") + public void testOverrideSuspendFun_Any_this() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/overrideSuspendFun_Any_this.kt"); + } + + @Test + @TestMetadata("overrideSuspendFun_Int.kt") + public void testOverrideSuspendFun_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/overrideSuspendFun_Int.kt"); + } + + @Test + @TestMetadata("returnResult.kt") + public void testReturnResult() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/returnResult.kt"); + } + + @Test + @TestMetadata("syntheticAccessor.kt") + public void testSyntheticAccessor() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resume/syntheticAccessor.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException") + @TestDataPath("$PROJECT_ROOT") + public class ResumeWithException { + @Test + public void testAllFilesPresentInResumeWithException() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("boxReturnValueOfSuspendFunctionReference.kt") + public void testBoxReturnValueOfSuspendFunctionReference() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxReturnValueOfSuspendFunctionReference.kt"); + } + + @Test + @TestMetadata("boxReturnValueOfSuspendLambda.kt") + public void testBoxReturnValueOfSuspendLambda() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxReturnValueOfSuspendLambda.kt"); + } + + @Test + @TestMetadata("boxTypeParameterOfSuperType.kt") + public void testBoxTypeParameterOfSuperType() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxTypeParameterOfSuperType.kt"); + } + + @Test + @TestMetadata("boxTypeParameterOfSuperTypeResult.kt") + public void testBoxTypeParameterOfSuperTypeResult() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxTypeParameterOfSuperTypeResult.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine.kt") + public void testBoxUnboxInsideCoroutine() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxUnboxInsideCoroutine.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine_Any.kt") + public void testBoxUnboxInsideCoroutine_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxUnboxInsideCoroutine_Any.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine_InlineAny.kt") + public void testBoxUnboxInsideCoroutine_InlineAny() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxUnboxInsideCoroutine_InlineAny.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine_InlineInt.kt") + public void testBoxUnboxInsideCoroutine_InlineInt() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxUnboxInsideCoroutine_InlineInt.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine_Int.kt") + public void testBoxUnboxInsideCoroutine_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxUnboxInsideCoroutine_Int.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine_Long.kt") + public void testBoxUnboxInsideCoroutine_Long() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxUnboxInsideCoroutine_Long.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine_NAny.kt") + public void testBoxUnboxInsideCoroutine_NAny() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxUnboxInsideCoroutine_NAny.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine_nonLocalReturn.kt") + public void testBoxUnboxInsideCoroutine_nonLocalReturn() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxUnboxInsideCoroutine_nonLocalReturn.kt"); + } + + @Test + @TestMetadata("boxUnboxInsideCoroutine_suspendFunType.kt") + public void testBoxUnboxInsideCoroutine_suspendFunType() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/boxUnboxInsideCoroutine_suspendFunType.kt"); + } + + @Test + @TestMetadata("bridgeGenerationCrossinline.kt") + public void testBridgeGenerationCrossinline() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/bridgeGenerationCrossinline.kt"); + } + + @Test + @TestMetadata("bridgeGenerationNonInline.kt") + public void testBridgeGenerationNonInline() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/bridgeGenerationNonInline.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFun.kt") + public void testCovariantOverrideSuspendFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFun.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunSameJvmType.kt") + public void testCovariantOverrideSuspendFunSameJvmType() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFunSameJvmType.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFunWithNullableInlineClass.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClassSameJvmType.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClassSameJvmType() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFunWithNullableInlineClassSameJvmType.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_Any.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFunWithNullableInlineClass_Any.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_Int.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFunWithNullableInlineClass_Int.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableAny() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFunWithNullableInlineClass_NullableAny_null.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt") + public void testCovariantOverrideSuspendFunWithNullableInlineClass_NullableInt() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFunWithNullableInlineClass_NullableInt.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFun_Any.kt") + public void testCovariantOverrideSuspendFun_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFun_Any.kt"); + } + + @Test + @TestMetadata("covariantOverrideSuspendFun_Int.kt") + public void testCovariantOverrideSuspendFun_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/covariantOverrideSuspendFun_Int.kt"); + } + + @Test + @TestMetadata("createMangling.kt") + public void testCreateMangling() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/createMangling.kt"); + } + + @Test + @TestMetadata("createOverride.kt") + public void testCreateOverride() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/createOverride.kt"); + } + + @Test + @TestMetadata("genericOverrideSuspendFun.kt") + public void testGenericOverrideSuspendFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/genericOverrideSuspendFun.kt"); + } + + @Test + @TestMetadata("genericOverrideSuspendFun_Any.kt") + public void testGenericOverrideSuspendFun_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/genericOverrideSuspendFun_Any.kt"); + } + + @Test + @TestMetadata("genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt") + public void testGenericOverrideSuspendFun_Any_NullableInlineClassUpperBound() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/genericOverrideSuspendFun_Any_NullableInlineClassUpperBound.kt"); + } + + @Test + @TestMetadata("genericOverrideSuspendFun_Int.kt") + public void testGenericOverrideSuspendFun_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/genericOverrideSuspendFun_Int.kt"); + } + + @Test + @TestMetadata("genericOverrideSuspendFun_NullableAny.kt") + public void testGenericOverrideSuspendFun_NullableAny() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/genericOverrideSuspendFun_NullableAny.kt"); + } + + @Test + @TestMetadata("genericOverrideSuspendFun_NullableInt.kt") + public void testGenericOverrideSuspendFun_NullableInt() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/genericOverrideSuspendFun_NullableInt.kt"); + } + + @Test + @TestMetadata("interfaceDelegateWithInlineClass.kt") + public void testInterfaceDelegateWithInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/interfaceDelegateWithInlineClass.kt"); + } + + @Test + @TestMetadata("invokeOperator.kt") + public void testInvokeOperator() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/invokeOperator.kt"); + } + + @Test + @TestMetadata("overrideSuspendFun.kt") + public void testOverrideSuspendFun() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/overrideSuspendFun.kt"); + } + + @Test + @TestMetadata("overrideSuspendFun_Any.kt") + public void testOverrideSuspendFun_Any() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/overrideSuspendFun_Any.kt"); + } + + @Test + @TestMetadata("overrideSuspendFun_Any_itf.kt") + public void testOverrideSuspendFun_Any_itf() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/overrideSuspendFun_Any_itf.kt"); + } + + @Test + @TestMetadata("overrideSuspendFun_Any_this.kt") + public void testOverrideSuspendFun_Any_this() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/overrideSuspendFun_Any_this.kt"); + } + + @Test + @TestMetadata("overrideSuspendFun_Int.kt") + public void testOverrideSuspendFun_Int() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/overrideSuspendFun_Int.kt"); + } + + @Test + @TestMetadata("returnResult.kt") + public void testReturnResult() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/inlineClasses/resumeWithException/returnResult.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/intLikeVarSpilling") + @TestDataPath("$PROJECT_ROOT") + public class IntLikeVarSpilling { + @Test + public void testAllFilesPresentInIntLikeVarSpilling() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intLikeVarSpilling"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("complicatedMerge.kt") + public void testComplicatedMerge() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/intLikeVarSpilling/complicatedMerge.kt"); + } + + @Test + @TestMetadata("i2bResult.kt") + public void testI2bResult() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/intLikeVarSpilling/i2bResult.kt"); + } + + @Test + @TestMetadata("listThrowablePairInOneSlot.kt") + public void testListThrowablePairInOneSlot() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/intLikeVarSpilling/listThrowablePairInOneSlot.kt"); + } + + @Test + @TestMetadata("loadFromBooleanArray.kt") + public void testLoadFromBooleanArray() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/intLikeVarSpilling/loadFromBooleanArray.kt"); + } + + @Test + @TestMetadata("loadFromByteArray.kt") + public void testLoadFromByteArray() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/intLikeVarSpilling/loadFromByteArray.kt"); + } + + @Test + @TestMetadata("noVariableInTable.kt") + public void testNoVariableInTable() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/intLikeVarSpilling/noVariableInTable.kt"); + } + + @Test + @TestMetadata("sameIconst1ManyVars.kt") + public void testSameIconst1ManyVars() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/intLikeVarSpilling/sameIconst1ManyVars.kt"); + } + + @Test + @TestMetadata("unusedCatchVar.kt") + public void testUnusedCatchVar() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/intLikeVarSpilling/unusedCatchVar.kt"); + } + + @Test + @TestMetadata("usedInMethodCall.kt") + public void testUsedInMethodCall() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/intLikeVarSpilling/usedInMethodCall.kt"); + } + + @Test + @TestMetadata("usedInVarStore.kt") + public void testUsedInVarStore() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/intLikeVarSpilling/usedInVarStore.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/intrinsicSemantics") + @TestDataPath("$PROJECT_ROOT") + public class IntrinsicSemantics { + @Test + public void testAllFilesPresentInIntrinsicSemantics() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/intrinsicSemantics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("coroutineContext.kt") + public void testCoroutineContext() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/intrinsicSemantics/coroutineContext.kt"); + } + + @Test + @TestMetadata("coroutineContextReceiver.kt") + public void testCoroutineContextReceiver() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/intrinsicSemantics/coroutineContextReceiver.kt"); + } + + @Test + @TestMetadata("coroutineContextReceiverNotIntrinsic.kt") + public void testCoroutineContextReceiverNotIntrinsic() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/intrinsicSemantics/coroutineContextReceiverNotIntrinsic.kt"); + } + + @Test + @TestMetadata("intercepted.kt") + public void testIntercepted() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/intrinsicSemantics/intercepted.kt"); + } + + @Test + @TestMetadata("releaseIntercepted.kt") + public void testReleaseIntercepted() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/intrinsicSemantics/releaseIntercepted.kt"); + } + + @Test + @TestMetadata("resultExceptionOrNullInLambda.kt") + public void testResultExceptionOrNullInLambda() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/intrinsicSemantics/resultExceptionOrNullInLambda.kt"); + } + + @Test + @TestMetadata("startCoroutine.kt") + public void testStartCoroutine() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/intrinsicSemantics/startCoroutine.kt"); + } + + @Test + @TestMetadata("startCoroutineUninterceptedOrReturn.kt") + public void testStartCoroutineUninterceptedOrReturn() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/intrinsicSemantics/startCoroutineUninterceptedOrReturn.kt"); + } + + @Test + @TestMetadata("startCoroutineUninterceptedOrReturnInterception.kt") + public void testStartCoroutineUninterceptedOrReturnInterception() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/intrinsicSemantics/startCoroutineUninterceptedOrReturnInterception.kt"); + } + + @Test + @TestMetadata("suspendCoroutineUninterceptedOrReturn.kt") + public void testSuspendCoroutineUninterceptedOrReturn() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/intrinsicSemantics/suspendCoroutineUninterceptedOrReturn.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/javaInterop") + @TestDataPath("$PROJECT_ROOT") + public class JavaInterop { + @Test + public void testAllFilesPresentInJavaInterop() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/javaInterop"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/localFunctions") + @TestDataPath("$PROJECT_ROOT") + public class LocalFunctions { + @Test + public void testAllFilesPresentInLocalFunctions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/localFunctions/named") + @TestDataPath("$PROJECT_ROOT") + public class Named { + @Test + public void testAllFilesPresentInNamed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/localFunctions/named"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("callTopLevelFromLocal.kt") + public void testCallTopLevelFromLocal() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/localFunctions/named/callTopLevelFromLocal.kt"); + } + + @Test + @TestMetadata("capturedParameters.kt") + public void testCapturedParameters() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/localFunctions/named/capturedParameters.kt"); + } + + @Test + @TestMetadata("capturedVariables.kt") + public void testCapturedVariables() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/localFunctions/named/capturedVariables.kt"); + } + + @Test + @TestMetadata("defaultArgument.kt") + public void testDefaultArgument() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/localFunctions/named/defaultArgument.kt"); + } + + @Test + @TestMetadata("extension.kt") + public void testExtension() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/localFunctions/named/extension.kt"); + } + + @Test + @TestMetadata("infix.kt") + public void testInfix() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/localFunctions/named/infix.kt"); + } + + @Test + @TestMetadata("insideLambda.kt") + public void testInsideLambda() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/localFunctions/named/insideLambda.kt"); + } + + @Test + @TestMetadata("nestedLocals.kt") + public void testNestedLocals() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/localFunctions/named/nestedLocals.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/localFunctions/named/simple.kt"); + } + + @Test + @TestMetadata("simpleSuspensionPoint.kt") + public void testSimpleSuspensionPoint() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/localFunctions/named/simpleSuspensionPoint.kt"); + } + + @Test + @TestMetadata("stateMachine.kt") + public void testStateMachine() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/localFunctions/named/stateMachine.kt"); + } + + @Test + @TestMetadata("withArguments.kt") + public void testWithArguments() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/localFunctions/named/withArguments.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/multiModule") + @TestDataPath("$PROJECT_ROOT") + public class MultiModule { + @Test + public void testAllFilesPresentInMultiModule() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/multiModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("inheritFromAnotherModule.kt") + public void testInheritFromAnotherModule() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/multiModule/inheritFromAnotherModule.kt"); + } + + @Test + @TestMetadata("inlineCrossModule.kt") + public void testInlineCrossModule() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/multiModule/inlineCrossModule.kt"); + } + + @Test + @TestMetadata("inlineFunctionWithOptionalParam.kt") + public void testInlineFunctionWithOptionalParam() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/multiModule/inlineFunctionWithOptionalParam.kt"); + } + + @Test + @TestMetadata("inlineMultiModule.kt") + public void testInlineMultiModule() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/multiModule/inlineMultiModule.kt"); + } + + @Test + @TestMetadata("inlineMultiModuleOverride.kt") + public void testInlineMultiModuleOverride() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/multiModule/inlineMultiModuleOverride.kt"); + } + + @Test + @TestMetadata("inlineMultiModuleWithController.kt") + public void testInlineMultiModuleWithController() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/multiModule/inlineMultiModuleWithController.kt"); + } + + @Test + @TestMetadata("inlineMultiModuleWithInnerInlining.kt") + public void testInlineMultiModuleWithInnerInlining() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/multiModule/inlineMultiModuleWithInnerInlining.kt"); + } + + @Test + @TestMetadata("inlineTailCall.kt") + public void testInlineTailCall() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/multiModule/inlineTailCall.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/multiModule/simple.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/redundantLocalsElimination") + @TestDataPath("$PROJECT_ROOT") + public class RedundantLocalsElimination { + @Test + public void testAllFilesPresentInRedundantLocalsElimination() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/redundantLocalsElimination"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("ktor_receivedMessage.kt") + public void testKtor_receivedMessage() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/redundantLocalsElimination/ktor_receivedMessage.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/reflect") + @TestDataPath("$PROJECT_ROOT") + public class Reflect { + @Test + public void testAllFilesPresentInReflect() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/reflect"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/stackUnwinding") + @TestDataPath("$PROJECT_ROOT") + public class StackUnwinding { + @Test + public void testAllFilesPresentInStackUnwinding() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/stackUnwinding"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("exception.kt") + public void testException() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/stackUnwinding/exception.kt"); + } + + @Test + @TestMetadata("inlineSuspendFunction.kt") + public void testInlineSuspendFunction() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/stackUnwinding/inlineSuspendFunction.kt"); + } + + @Test + @TestMetadata("rethrowInFinally.kt") + public void testRethrowInFinally() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/stackUnwinding/rethrowInFinally.kt"); + } + + @Test + @TestMetadata("rethrowInFinallyWithSuspension.kt") + public void testRethrowInFinallyWithSuspension() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/stackUnwinding/rethrowInFinallyWithSuspension.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/stackUnwinding/simple.kt"); + } + + @Test + @TestMetadata("suspendInCycle.kt") + public void testSuspendInCycle() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/stackUnwinding/suspendInCycle.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/suspendConversion") + @TestDataPath("$PROJECT_ROOT") + public class SuspendConversion { + @Test + public void testAllFilesPresentInSuspendConversion() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendConversion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("intersectionTypeToSubtypeConversion.kt") + public void testIntersectionTypeToSubtypeConversion() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendConversion/intersectionTypeToSubtypeConversion.kt"); + } + + @Test + @TestMetadata("onArgument.kt") + public void testOnArgument() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendConversion/onArgument.kt"); + } + + @Test + @TestMetadata("onInlineArgument.kt") + public void testOnInlineArgument() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendConversion/onInlineArgument.kt"); + } + + @Test + @TestMetadata("subtypeOfFunctionalTypeToSuspendConversion.kt") + public void testSubtypeOfFunctionalTypeToSuspendConversion() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendConversion/subtypeOfFunctionalTypeToSuspendConversion.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine") + @TestDataPath("$PROJECT_ROOT") + public class SuspendFunctionAsCoroutine { + @Test + public void testAllFilesPresentInSuspendFunctionAsCoroutine() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("dispatchResume.kt") + public void testDispatchResume() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/dispatchResume.kt"); + } + + @Test + @TestMetadata("handleException.kt") + public void testHandleException() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/handleException.kt"); + } + + @Test + @TestMetadata("ifExpressionInsideCoroutine_1_3.kt") + public void testIfExpressionInsideCoroutine_1_3() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/ifExpressionInsideCoroutine_1_3.kt"); + } + + @Test + @TestMetadata("inline.kt") + public void testInline() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/inline.kt"); + } + + @Test + @TestMetadata("inlineTwoReceivers.kt") + public void testInlineTwoReceivers() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/inlineTwoReceivers.kt"); + } + + @Test + @TestMetadata("member.kt") + public void testMember() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/member.kt"); + } + + @Test + @TestMetadata("noinlineTwoReceivers.kt") + public void testNoinlineTwoReceivers() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/noinlineTwoReceivers.kt"); + } + + @Test + @TestMetadata("operators.kt") + public void testOperators() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/operators.kt"); + } + + @Test + @TestMetadata("privateFunctions.kt") + public void testPrivateFunctions() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/privateFunctions.kt"); + } + + @Test + @TestMetadata("privateInFile.kt") + public void testPrivateInFile() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/privateInFile.kt"); + } + + @Test + @TestMetadata("returnNoSuspend.kt") + public void testReturnNoSuspend() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/returnNoSuspend.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/simple.kt"); + } + + @Test + @TestMetadata("superCall.kt") + public void testSuperCall() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/superCall.kt"); + } + + @Test + @TestMetadata("superCallAbstractClass.kt") + public void testSuperCallAbstractClass() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/superCallAbstractClass.kt"); + } + + @Test + @TestMetadata("superCallInterface.kt") + public void testSuperCallInterface() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/superCallInterface.kt"); + } + + @Test + @TestMetadata("superCallOverload.kt") + public void testSuperCallOverload() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/superCallOverload.kt"); + } + + @Test + @TestMetadata("withVariables.kt") + public void testWithVariables() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunctionAsCoroutine/withVariables.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall") + @TestDataPath("$PROJECT_ROOT") + public class SuspendFunctionTypeCall { + @Test + public void testAllFilesPresentInSuspendFunctionTypeCall() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("localVal.kt") + public void testLocalVal() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall/localVal.kt"); + } + + @Test + @TestMetadata("manyParameters.kt") + public void testManyParameters() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall/manyParameters.kt"); + } + + @Test + @TestMetadata("manyParametersNoCapture.kt") + public void testManyParametersNoCapture() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall/manyParametersNoCapture.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall/simple.kt"); + } + + @Test + @TestMetadata("suspendModifier.kt") + public void testSuspendModifier() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/suspendFunctionTypeCall/suspendModifier.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/tailCallOptimizations") + @TestDataPath("$PROJECT_ROOT") + public class TailCallOptimizations { + @Test + public void testAllFilesPresentInTailCallOptimizations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("crossinline.kt") + public void testCrossinline() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/crossinline.kt"); + } + + @Test + @TestMetadata("inlineWithoutStateMachine.kt") + public void testInlineWithoutStateMachine() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/inlineWithoutStateMachine.kt"); + } + + @Test + @TestMetadata("innerObjectRetransformation.kt") + public void testInnerObjectRetransformation() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/innerObjectRetransformation.kt"); + } + + @Test + @TestMetadata("tryCatch.kt") + public void testTryCatch() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailCallOptimizations/tryCatch.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unit") + @TestDataPath("$PROJECT_ROOT") + public class Unit { + @Test + public void testAllFilesPresentInUnit() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailCallOptimizations/unit"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/tailOperations") + @TestDataPath("$PROJECT_ROOT") + public class TailOperations { + @Test + public void testAllFilesPresentInTailOperations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/tailOperations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("suspendWithIf.kt") + public void testSuspendWithIf() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailOperations/suspendWithIf.kt"); + } + + @Test + @TestMetadata("suspendWithTryCatch.kt") + public void testSuspendWithTryCatch() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailOperations/suspendWithTryCatch.kt"); + } + + @Test + @TestMetadata("suspendWithWhen.kt") + public void testSuspendWithWhen() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailOperations/suspendWithWhen.kt"); + } + + @Test + @TestMetadata("tailInlining.kt") + public void testTailInlining() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/tailOperations/tailInlining.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/unitTypeReturn") + @TestDataPath("$PROJECT_ROOT") + public class UnitTypeReturn { + @Test + public void testAllFilesPresentInUnitTypeReturn() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/unitTypeReturn"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("coroutineNonLocalReturn.kt") + public void testCoroutineNonLocalReturn() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/unitTypeReturn/coroutineNonLocalReturn.kt"); + } + + @Test + @TestMetadata("coroutineReturn.kt") + public void testCoroutineReturn() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/unitTypeReturn/coroutineReturn.kt"); + } + + @Test + @TestMetadata("inlineUnitFunction.kt") + public void testInlineUnitFunction() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/unitTypeReturn/inlineUnitFunction.kt"); + } + + @Test + @TestMetadata("interfaceDelegation.kt") + public void testInterfaceDelegation() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/unitTypeReturn/interfaceDelegation.kt"); + } + + @Test + @TestMetadata("suspendNonLocalReturn.kt") + public void testSuspendNonLocalReturn() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/unitTypeReturn/suspendNonLocalReturn.kt"); + } + + @Test + @TestMetadata("suspendReturn.kt") + public void testSuspendReturn() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/unitTypeReturn/suspendReturn.kt"); + } + + @Test + @TestMetadata("unitSafeCall.kt") + public void testUnitSafeCall() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/unitTypeReturn/unitSafeCall.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/varSpilling") + @TestDataPath("$PROJECT_ROOT") + public class VarSpilling { + @Test + public void testAllFilesPresentInVarSpilling() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/varSpilling"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("fakeInlinerVariables.kt") + public void testFakeInlinerVariables() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/varSpilling/fakeInlinerVariables.kt"); + } + + @Test + @TestMetadata("kt19475.kt") + public void testKt19475() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/varSpilling/kt19475.kt"); + } + + @Test + @TestMetadata("kt38925.kt") + public void testKt38925() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/varSpilling/kt38925.kt"); + } + + @Test + @TestMetadata("kt49834.kt") + public void testKt49834() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/varSpilling/kt49834.kt"); + } + + @Test + @TestMetadata("lvtWithInlineOnly.kt") + public void testLvtWithInlineOnly() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/varSpilling/lvtWithInlineOnly.kt"); + } + + @Test + @TestMetadata("nullSpilling.kt") + public void testNullSpilling() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/varSpilling/nullSpilling.kt"); + } + + @Test + @TestMetadata("refinedIntTypesAnalysis.kt") + public void testRefinedIntTypesAnalysis() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/varSpilling/refinedIntTypesAnalysis.kt"); + } + + @Test + @TestMetadata("safeCallElvis.kt") + public void testSafeCallElvis() throws Exception { + runTest("compiler/testData/codegen/box/coroutines/varSpilling/safeCallElvis.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/varSpilling/cleanup") + @TestDataPath("$PROJECT_ROOT") + public class Cleanup { + @Test + public void testAllFilesPresentInCleanup() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/varSpilling/cleanup"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/coroutines/varSpilling/debugMode") + @TestDataPath("$PROJECT_ROOT") + public class DebugMode { + @Test + public void testAllFilesPresentInDebugMode() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/coroutines/varSpilling/debugMode"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/correctFrontendCode") + @TestDataPath("$PROJECT_ROOT") + public class CorrectFrontendCode { + @Test + public void testAllFilesPresentInCorrectFrontendCode() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/correctFrontendCode"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("privateNestedClassInSuper.kt") + public void testPrivateNestedClassInSuper() throws Exception { + runTest("compiler/testData/codegen/box/correctFrontendCode/privateNestedClassInSuper.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/dataClasses") + @TestDataPath("$PROJECT_ROOT") + public class DataClasses { + @Test + public void testAllFilesPresentInDataClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("arrayParams.kt") + public void testArrayParams() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/arrayParams.kt"); + } + + @Test + @TestMetadata("changingVarParam.kt") + public void testChangingVarParam() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/changingVarParam.kt"); + } + + @Test + @TestMetadata("dataClassWithManyFields.kt") + public void testDataClassWithManyFields() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/dataClassWithManyFields.kt"); + } + + @Test + @TestMetadata("doubleParam.kt") + public void testDoubleParam() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/doubleParam.kt"); + } + + @Test + @TestMetadata("equalityChecksPrimitiveUnboxed.kt") + public void testEqualityChecksPrimitiveUnboxed() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/equalityChecksPrimitiveUnboxed.kt"); + } + + @Test + @TestMetadata("floatParam.kt") + public void testFloatParam() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/floatParam.kt"); + } + + @Test + @TestMetadata("fromOtherModule.kt") + public void testFromOtherModule() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/fromOtherModule.kt"); + } + + @Test + @TestMetadata("genericParam.kt") + public void testGenericParam() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/genericParam.kt"); + } + + @Test + @TestMetadata("kt49715.kt") + public void testKt49715() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/kt49715.kt"); + } + + @Test + @TestMetadata("kt49715_behaviorChange.kt") + public void testKt49715_behaviorChange() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/kt49715_behaviorChange.kt"); + } + + @Test + @TestMetadata("mixedParams.kt") + public void testMixedParams() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/mixedParams.kt"); + } + + @Test + @TestMetadata("multiDeclaration.kt") + public void testMultiDeclaration() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/multiDeclaration.kt"); + } + + @Test + @TestMetadata("multiDeclarationFor.kt") + public void testMultiDeclarationFor() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/multiDeclarationFor.kt"); + } + + @Test + @TestMetadata("nonTrivialFinalMemberInSuperClass.kt") + public void testNonTrivialFinalMemberInSuperClass() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/nonTrivialFinalMemberInSuperClass.kt"); + } + + @Test + @TestMetadata("nonTrivialMemberInSuperClass.kt") + public void testNonTrivialMemberInSuperClass() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/nonTrivialMemberInSuperClass.kt"); + } + + @Test + @TestMetadata("privateValParams.kt") + public void testPrivateValParams() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/privateValParams.kt"); + } + + @Test + @TestMetadata("twoValParams.kt") + public void testTwoValParams() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/twoValParams.kt"); + } + + @Test + @TestMetadata("twoVarParams.kt") + public void testTwoVarParams() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/twoVarParams.kt"); + } + + @Test + @TestMetadata("unitComponent.kt") + public void testUnitComponent() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/unitComponent.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/dataClasses/components") + @TestDataPath("$PROJECT_ROOT") + public class Components { + @Test + public void testAllFilesPresentInComponents() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/components"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt49812.kt") + public void testKt49812() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/components/kt49812.kt"); + } + + @Test + @TestMetadata("kt49936.kt") + public void testKt49936() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/components/kt49936.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/dataClasses/copy") + @TestDataPath("$PROJECT_ROOT") + public class Copy { + @Test + public void testAllFilesPresentInCopy() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/copy"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("constructorWithDefaultParam.kt") + public void testConstructorWithDefaultParam() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/copy/constructorWithDefaultParam.kt"); + } + + @Test + @TestMetadata("copyInObjectNestedDataClass.kt") + public void testCopyInObjectNestedDataClass() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/copy/copyInObjectNestedDataClass.kt"); + } + + @Test + @TestMetadata("kt12708.kt") + public void testKt12708() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/copy/kt12708.kt"); + } + + @Test + @TestMetadata("kt3033.kt") + public void testKt3033() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/copy/kt3033.kt"); + } + + @Test + @TestMetadata("valInConstructorParams.kt") + public void testValInConstructorParams() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/copy/valInConstructorParams.kt"); + } + + @Test + @TestMetadata("varInConstructorParams.kt") + public void testVarInConstructorParams() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/copy/varInConstructorParams.kt"); + } + + @Test + @TestMetadata("withGenericParameter.kt") + public void testWithGenericParameter() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/copy/withGenericParameter.kt"); + } + + @Test + @TestMetadata("withSecondaryConstructor.kt") + public void testWithSecondaryConstructor() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/copy/withSecondaryConstructor.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/dataClasses/equals") + @TestDataPath("$PROJECT_ROOT") + public class Equals { + @Test + public void testAllFilesPresentInEquals() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/equals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("alreadyDeclared.kt") + public void testAlreadyDeclared() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/equals/alreadyDeclared.kt"); + } + + @Test + @TestMetadata("genericarray.kt") + public void testGenericarray() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/equals/genericarray.kt"); + } + + @Test + @TestMetadata("intarray.kt") + public void testIntarray() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/equals/intarray.kt"); + } + + @Test + @TestMetadata("null.kt") + public void testNull() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/equals/null.kt"); + } + + @Test + @TestMetadata("nullother.kt") + public void testNullother() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/equals/nullother.kt"); + } + + @Test + @TestMetadata("sameinstance.kt") + public void testSameinstance() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/equals/sameinstance.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/dataClasses/hashCode") + @TestDataPath("$PROJECT_ROOT") + public class HashCode { + @Test + public void testAllFilesPresentInHashCode() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/hashCode"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("alreadyDeclared.kt") + public void testAlreadyDeclared() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/hashCode/alreadyDeclared.kt"); + } + + @Test + @TestMetadata("boolean.kt") + public void testBoolean() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/hashCode/boolean.kt"); + } + + @Test + @TestMetadata("byte.kt") + public void testByte() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/hashCode/byte.kt"); + } + + @Test + @TestMetadata("char.kt") + public void testChar() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/hashCode/char.kt"); + } + + @Test + @TestMetadata("double.kt") + public void testDouble() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/hashCode/double.kt"); + } + + @Test + @TestMetadata("float.kt") + public void testFloat() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/hashCode/float.kt"); + } + + @Test + @TestMetadata("genericNull.kt") + public void testGenericNull() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/hashCode/genericNull.kt"); + } + + @Test + @TestMetadata("int.kt") + public void testInt() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/hashCode/int.kt"); + } + + @Test + @TestMetadata("long.kt") + public void testLong() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/hashCode/long.kt"); + } + + @Test + @TestMetadata("null.kt") + public void testNull() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/hashCode/null.kt"); + } + + @Test + @TestMetadata("short.kt") + public void testShort() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/hashCode/short.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/dataClasses/toString") + @TestDataPath("$PROJECT_ROOT") + public class ToString { + @Test + public void testAllFilesPresentInToString() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataClasses/toString"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("alreadyDeclared.kt") + public void testAlreadyDeclared() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/toString/alreadyDeclared.kt"); + } + + @Test + @TestMetadata("arrayParams.kt") + public void testArrayParams() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/toString/arrayParams.kt"); + } + + @Test + @TestMetadata("changingVarParam.kt") + public void testChangingVarParam() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/toString/changingVarParam.kt"); + } + + @Test + @TestMetadata("genericParam.kt") + public void testGenericParam() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/toString/genericParam.kt"); + } + + @Test + @TestMetadata("mixedParams.kt") + public void testMixedParams() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/toString/mixedParams.kt"); + } + + @Test + @TestMetadata("primitiveArrays.kt") + public void testPrimitiveArrays() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/toString/primitiveArrays.kt"); + } + + @Test + @TestMetadata("unitComponent.kt") + public void testUnitComponent() throws Exception { + runTest("compiler/testData/codegen/box/dataClasses/toString/unitComponent.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/dataObjects") + @TestDataPath("$PROJECT_ROOT") + public class DataObjects { + @Test + public void testAllFilesPresentInDataObjects() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/dataObjects"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("equals.kt") + public void testEquals() throws Exception { + runTest("compiler/testData/codegen/box/dataObjects/equals.kt"); + } + + @Test + @TestMetadata("hashCode.kt") + public void testHashCode() throws Exception { + runTest("compiler/testData/codegen/box/dataObjects/hashCode.kt"); + } + + @Test + @TestMetadata("toString.kt") + public void testToString() throws Exception { + runTest("compiler/testData/codegen/box/dataObjects/toString.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/deadCodeElimination") + @TestDataPath("$PROJECT_ROOT") + public class DeadCodeElimination { + @Test + public void testAllFilesPresentInDeadCodeElimination() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/deadCodeElimination"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("emptyVariableRange.kt") + public void testEmptyVariableRange() throws Exception { + runTest("compiler/testData/codegen/box/deadCodeElimination/emptyVariableRange.kt"); + } + + @Test + @TestMetadata("intersectingVariableRange.kt") + public void testIntersectingVariableRange() throws Exception { + runTest("compiler/testData/codegen/box/deadCodeElimination/intersectingVariableRange.kt"); + } + + @Test + @TestMetadata("intersectingVariableRangeInFinally.kt") + public void testIntersectingVariableRangeInFinally() throws Exception { + runTest("compiler/testData/codegen/box/deadCodeElimination/intersectingVariableRangeInFinally.kt"); + } + + @Test + @TestMetadata("kt14357.kt") + public void testKt14357() throws Exception { + runTest("compiler/testData/codegen/box/deadCodeElimination/kt14357.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/defaultArguments") + @TestDataPath("$PROJECT_ROOT") + public class DefaultArguments { + @Test + public void testAllFilesPresentInDefaultArguments() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("callDefaultFromInitializer.kt") + public void testCallDefaultFromInitializer() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/callDefaultFromInitializer.kt"); + } + + @Test + @TestMetadata("captureInTailrec.kt") + public void testCaptureInTailrec() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/captureInTailrec.kt"); + } + + @Test + @TestMetadata("complexInheritance.kt") + public void testComplexInheritance() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/complexInheritance.kt"); + } + + @Test + @TestMetadata("implementedByFake.kt") + public void testImplementedByFake() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/implementedByFake.kt"); + } + + @Test + @TestMetadata("implementedByFake2.kt") + public void testImplementedByFake2() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/implementedByFake2.kt"); + } + + @Test + @TestMetadata("implementedByFake3.kt") + public void testImplementedByFake3() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/implementedByFake3.kt"); + } + + @Test + @TestMetadata("inheritedFromInterfaceViaAbstractSuperclass.kt") + public void testInheritedFromInterfaceViaAbstractSuperclass() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/inheritedFromInterfaceViaAbstractSuperclass.kt"); + } + + @Test + @TestMetadata("kt36853.kt") + public void testKt36853() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/kt36853.kt"); + } + + @Test + @TestMetadata("kt36853_fibonacci.kt") + public void testKt36853_fibonacci() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/kt36853_fibonacci.kt"); + } + + @Test + @TestMetadata("kt36853_nestedObject.kt") + public void testKt36853_nestedObject() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/kt36853_nestedObject.kt"); + } + + @Test + @TestMetadata("kt36853a.kt") + public void testKt36853a() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/kt36853a.kt"); + } + + @Test + @TestMetadata("kt46189.kt") + public void testKt46189() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/kt46189.kt"); + } + + @Test + @TestMetadata("kt47073.kt") + public void testKt47073() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/kt47073.kt"); + } + + @Test + @TestMetadata("kt47073_nested.kt") + public void testKt47073_nested() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/kt47073_nested.kt"); + } + + @Test + @TestMetadata("kt48391.kt") + public void testKt48391() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/kt48391.kt"); + } + + @Test + @TestMetadata("kt52702.kt") + public void testKt52702() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/kt52702.kt"); + } + + @Test + @TestMetadata("kt6382.kt") + public void testKt6382() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/kt6382.kt"); + } + + @Test + @TestMetadata("protected.kt") + public void testProtected() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/protected.kt"); + } + + @Test + @TestMetadata("recursiveDefaultArguments.kt") + public void testRecursiveDefaultArguments() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/recursiveDefaultArguments.kt"); + } + + @Test + @TestMetadata("referenceAsArg.kt") + public void testReferenceAsArg() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/referenceAsArg.kt"); + } + + @Test + @TestMetadata("simpleFromOtherFile.kt") + public void testSimpleFromOtherFile() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/simpleFromOtherFile.kt"); + } + + @Test + @TestMetadata("useNextParamInLambda.kt") + public void testUseNextParamInLambda() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/useNextParamInLambda.kt"); + } + + @Test + @TestMetadata("useNextParamInLambdaTailrec.kt") + public void testUseNextParamInLambdaTailrec() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/useNextParamInLambdaTailrec.kt"); + } + + @Test + @TestMetadata("useThisInLambda.kt") + public void testUseThisInLambda() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/useThisInLambda.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/defaultArguments/constructor") + @TestDataPath("$PROJECT_ROOT") + public class Constructor { + @Test + public void testAllFilesPresentInConstructor() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/constructor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("annotation.kt") + public void testAnnotation() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/constructor/annotation.kt"); + } + + @Test + @TestMetadata("annotationWithEmptyArray.kt") + public void testAnnotationWithEmptyArray() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/constructor/annotationWithEmptyArray.kt"); + } + + @Test + @TestMetadata("defArgs1.kt") + public void testDefArgs1() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/constructor/defArgs1.kt"); + } + + @Test + @TestMetadata("defArgs1InnerClass.kt") + public void testDefArgs1InnerClass() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/constructor/defArgs1InnerClass.kt"); + } + + @Test + @TestMetadata("defArgs2.kt") + public void testDefArgs2() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/constructor/defArgs2.kt"); + } + + @Test + @TestMetadata("doubleDefArgs1InnerClass.kt") + public void testDoubleDefArgs1InnerClass() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/constructor/doubleDefArgs1InnerClass.kt"); + } + + @Test + @TestMetadata("enum.kt") + public void testEnum() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/constructor/enum.kt"); + } + + @Test + @TestMetadata("enumWithOneDefArg.kt") + public void testEnumWithOneDefArg() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/constructor/enumWithOneDefArg.kt"); + } + + @Test + @TestMetadata("enumWithTwoDefArgs.kt") + public void testEnumWithTwoDefArgs() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/constructor/enumWithTwoDefArgs.kt"); + } + + @Test + @TestMetadata("enumWithTwoDoubleDefArgs.kt") + public void testEnumWithTwoDoubleDefArgs() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/constructor/enumWithTwoDoubleDefArgs.kt"); + } + + @Test + @TestMetadata("innerClass32Args.kt") + public void testInnerClass32Args() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/constructor/innerClass32Args.kt"); + } + + @Test + @TestMetadata("kt2852.kt") + public void testKt2852() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/constructor/kt2852.kt"); + } + + @Test + @TestMetadata("kt30517.kt") + public void testKt30517() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/constructor/kt30517.kt"); + } + + @Test + @TestMetadata("kt3060.kt") + public void testKt3060() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/constructor/kt3060.kt"); + } + + @Test + @TestMetadata("objectExpressionDelegatingToSecondaryConstructor.kt") + public void testObjectExpressionDelegatingToSecondaryConstructor() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/constructor/objectExpressionDelegatingToSecondaryConstructor.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/defaultArguments/convention") + @TestDataPath("$PROJECT_ROOT") + public class Convention { + @Test + public void testAllFilesPresentInConvention() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/convention"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("incWithDefaultInGetter.kt") + public void testIncWithDefaultInGetter() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/convention/incWithDefaultInGetter.kt"); + } + + @Test + @TestMetadata("incWithDefaults.kt") + public void testIncWithDefaults() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/convention/incWithDefaults.kt"); + } + + @Test + @TestMetadata("kt16520.kt") + public void testKt16520() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/convention/kt16520.kt"); + } + + @Test + @TestMetadata("kt9140.kt") + public void testKt9140() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/convention/kt9140.kt"); + } + + @Test + @TestMetadata("plusAssignWithDefaultInGetter.kt") + public void testPlusAssignWithDefaultInGetter() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/convention/plusAssignWithDefaultInGetter.kt"); + } + + @Test + @TestMetadata("plusAssignWithDefaults.kt") + public void testPlusAssignWithDefaults() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/convention/plusAssignWithDefaults.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/defaultArguments/function") + @TestDataPath("$PROJECT_ROOT") + public class Function { + @Test + @TestMetadata("abstractClass.kt") + public void testAbstractClass() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/abstractClass.kt"); + } + + @Test + public void testAllFilesPresentInFunction() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/function"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("complexInheritance.kt") + public void testComplexInheritance() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/complexInheritance.kt"); + } + + @Test + @TestMetadata("covariantOverride.kt") + public void testCovariantOverride() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/covariantOverride.kt"); + } + + @Test + @TestMetadata("covariantOverrideGeneric.kt") + public void testCovariantOverrideGeneric() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/covariantOverrideGeneric.kt"); + } + + @Test + @TestMetadata("defaultLambdaInline.kt") + public void testDefaultLambdaInline() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/defaultLambdaInline.kt"); + } + + @Test + @TestMetadata("extensionFunctionManyArgs.kt") + public void testExtensionFunctionManyArgs() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/extensionFunctionManyArgs.kt"); + } + + @Test + @TestMetadata("extentionFunction.kt") + public void testExtentionFunction() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/extentionFunction.kt"); + } + + @Test + @TestMetadata("extentionFunctionDouble.kt") + public void testExtentionFunctionDouble() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/extentionFunctionDouble.kt"); + } + + @Test + @TestMetadata("extentionFunctionDoubleTwoArgs.kt") + public void testExtentionFunctionDoubleTwoArgs() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/extentionFunctionDoubleTwoArgs.kt"); + } + + @Test + @TestMetadata("extentionFunctionInClassObject.kt") + public void testExtentionFunctionInClassObject() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/extentionFunctionInClassObject.kt"); + } + + @Test + @TestMetadata("extentionFunctionInObject.kt") + public void testExtentionFunctionInObject() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/extentionFunctionInObject.kt"); + } + + @Test + @TestMetadata("extentionFunctionWithOneDefArg.kt") + public void testExtentionFunctionWithOneDefArg() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/extentionFunctionWithOneDefArg.kt"); + } + + @Test + @TestMetadata("funInTrait.kt") + public void testFunInTrait() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/funInTrait.kt"); + } + + @Test + @TestMetadata("funInTraitChain.kt") + public void testFunInTraitChain() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/funInTraitChain.kt"); + } + + @Test + @TestMetadata("innerExtentionFunction.kt") + public void testInnerExtentionFunction() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/innerExtentionFunction.kt"); + } + + @Test + @TestMetadata("innerExtentionFunctionDouble.kt") + public void testInnerExtentionFunctionDouble() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/innerExtentionFunctionDouble.kt"); + } + + @Test + @TestMetadata("innerExtentionFunctionDoubleTwoArgs.kt") + public void testInnerExtentionFunctionDoubleTwoArgs() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/innerExtentionFunctionDoubleTwoArgs.kt"); + } + + @Test + @TestMetadata("innerExtentionFunctionManyArgs.kt") + public void testInnerExtentionFunctionManyArgs() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/innerExtentionFunctionManyArgs.kt"); + } + + @Test + @TestMetadata("kt15971.kt") + public void testKt15971() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/kt15971.kt"); + } + + @Test + @TestMetadata("kt15971_2.kt") + public void testKt15971_2() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/kt15971_2.kt"); + } + + @Test + @TestMetadata("kt15971_3.kt") + public void testKt15971_3() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/kt15971_3.kt"); + } + + @Test + @TestMetadata("kt36188.kt") + public void testKt36188() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/kt36188.kt"); + } + + @Test + @TestMetadata("kt36188_2.kt") + public void testKt36188_2() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/kt36188_2.kt"); + } + + @Test + @TestMetadata("kt5232.kt") + public void testKt5232() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/kt5232.kt"); + } + + @Test + @TestMetadata("memberFunctionManyArgs.kt") + public void testMemberFunctionManyArgs() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/memberFunctionManyArgs.kt"); + } + + @Test + @TestMetadata("mixingNamedAndPositioned.kt") + public void testMixingNamedAndPositioned() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/mixingNamedAndPositioned.kt"); + } + + @Test + @TestMetadata("topLevelManyArgs.kt") + public void testTopLevelManyArgs() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/topLevelManyArgs.kt"); + } + + @Test + @TestMetadata("trait.kt") + public void testTrait() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/function/trait.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/defaultArguments/private") + @TestDataPath("$PROJECT_ROOT") + public class Private { + @Test + public void testAllFilesPresentInPrivate() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/private"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("memberExtensionFunction.kt") + public void testMemberExtensionFunction() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/private/memberExtensionFunction.kt"); + } + + @Test + @TestMetadata("memberFunction.kt") + public void testMemberFunction() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/private/memberFunction.kt"); + } + + @Test + @TestMetadata("primaryConstructor.kt") + public void testPrimaryConstructor() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/private/primaryConstructor.kt"); + } + + @Test + @TestMetadata("secondaryConstructor.kt") + public void testSecondaryConstructor() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/private/secondaryConstructor.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/defaultArguments/signature") + @TestDataPath("$PROJECT_ROOT") + public class Signature { + @Test + public void testAllFilesPresentInSignature() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/defaultArguments/signature"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt2789.kt") + public void testKt2789() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/signature/kt2789.kt"); + } + + @Test + @TestMetadata("kt9428.kt") + public void testKt9428() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/signature/kt9428.kt"); + } + + @Test + @TestMetadata("kt9924.kt") + public void testKt9924() throws Exception { + runTest("compiler/testData/codegen/box/defaultArguments/signature/kt9924.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/delegatedProperty") + @TestDataPath("$PROJECT_ROOT") + public class DelegatedProperty { + @Test + @TestMetadata("accessTopLevelDelegatedPropertyInClinit.kt") + public void testAccessTopLevelDelegatedPropertyInClinit() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/accessTopLevelDelegatedPropertyInClinit.kt"); + } + + @Test + public void testAllFilesPresentInDelegatedProperty() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("beforeDeclarationContainerOptimization.kt") + public void testBeforeDeclarationContainerOptimization() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/beforeDeclarationContainerOptimization.kt"); + } + + @Test + @TestMetadata("capturePropertyInClosure.kt") + public void testCapturePropertyInClosure() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/capturePropertyInClosure.kt"); + } + + @Test + @TestMetadata("castGetReturnType.kt") + public void testCastGetReturnType() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/castGetReturnType.kt"); + } + + @Test + @TestMetadata("castSetParameter.kt") + public void testCastSetParameter() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/castSetParameter.kt"); + } + + @Test + @TestMetadata("delegateAsInnerClass.kt") + public void testDelegateAsInnerClass() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateAsInnerClass.kt"); + } + + @Test + @TestMetadata("delegateByOtherProperty.kt") + public void testDelegateByOtherProperty() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateByOtherProperty.kt"); + } + + @Test + @TestMetadata("delegateByTopLevelFun.kt") + public void testDelegateByTopLevelFun() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateByTopLevelFun.kt"); + } + + @Test + @TestMetadata("delegateByTopLevelProperty.kt") + public void testDelegateByTopLevelProperty() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateByTopLevelProperty.kt"); + } + + @Test + @TestMetadata("delegateForExtProperty.kt") + public void testDelegateForExtProperty() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateForExtProperty.kt"); + } + + @Test + @TestMetadata("delegateForExtPropertyInClass.kt") + public void testDelegateForExtPropertyInClass() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateForExtPropertyInClass.kt"); + } + + @Test + @TestMetadata("delegateToConstructorParameter.kt") + public void testDelegateToConstructorParameter() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToConstructorParameter.kt"); + } + + @Test + @TestMetadata("delegateWithPrivateSet.kt") + public void testDelegateWithPrivateSet() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateWithPrivateSet.kt"); + } + + @Test + @TestMetadata("delegatedPropertyInEnum.kt") + public void testDelegatedPropertyInEnum() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegatedPropertyInEnum.kt"); + } + + @Test + @TestMetadata("extensionDelegatesWithSameNames.kt") + public void testExtensionDelegatesWithSameNames() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/extensionDelegatesWithSameNames.kt"); + } + + @Test + @TestMetadata("extensionPropertyAndExtensionGetValue.kt") + public void testExtensionPropertyAndExtensionGetValue() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/extensionPropertyAndExtensionGetValue.kt"); + } + + @Test + @TestMetadata("functionRefDelefate.kt") + public void testFunctionRefDelefate() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/functionRefDelefate.kt"); + } + + @Test + @TestMetadata("genericDelegate.kt") + public void testGenericDelegate() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/genericDelegate.kt"); + } + + @Test + @TestMetadata("genericDelegateUncheckedCast1.kt") + public void testGenericDelegateUncheckedCast1() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/genericDelegateUncheckedCast1.kt"); + } + + @Test + @TestMetadata("genericDelegateUncheckedCast2.kt") + public void testGenericDelegateUncheckedCast2() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/genericDelegateUncheckedCast2.kt"); + } + + @Test + @TestMetadata("genericSetValueViaSyntheticAccessor.kt") + public void testGenericSetValueViaSyntheticAccessor() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/genericSetValueViaSyntheticAccessor.kt"); + } + + @Test + @TestMetadata("getAsExtensionFun.kt") + public void testGetAsExtensionFun() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/getAsExtensionFun.kt"); + } + + @Test + @TestMetadata("getAsExtensionFunInClass.kt") + public void testGetAsExtensionFunInClass() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/getAsExtensionFunInClass.kt"); + } + + @Test + @TestMetadata("inClassVal.kt") + public void testInClassVal() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/inClassVal.kt"); + } + + @Test + @TestMetadata("inClassVar.kt") + public void testInClassVar() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/inClassVar.kt"); + } + + @Test + @TestMetadata("inTrait.kt") + public void testInTrait() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/inTrait.kt"); + } + + @Test + @TestMetadata("inferredPropertyType.kt") + public void testInferredPropertyType() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/inferredPropertyType.kt"); + } + + @Test + @TestMetadata("insideInlinedObjectMultiModule.kt") + public void testInsideInlinedObjectMultiModule() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/insideInlinedObjectMultiModule.kt"); + } + + @Test + @TestMetadata("kt35707.kt") + public void testKt35707() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/kt35707.kt"); + } + + @Test + @TestMetadata("kt37204.kt") + public void testKt37204() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/kt37204.kt"); + } + + @Test + @TestMetadata("kt4138.kt") + public void testKt4138() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/kt4138.kt"); + } + + @Test + @TestMetadata("kt45431.kt") + public void testKt45431() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/kt45431.kt"); + } + + @Test + @TestMetadata("kt6722.kt") + public void testKt6722() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/kt6722.kt"); + } + + @Test + @TestMetadata("kt9712.kt") + public void testKt9712() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/kt9712.kt"); + } + + @Test + @TestMetadata("privateVar.kt") + public void testPrivateVar() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/privateVar.kt"); + } + + @Test + @TestMetadata("protectedVarWithPrivateSet.kt") + public void testProtectedVarWithPrivateSet() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/protectedVarWithPrivateSet.kt"); + } + + @Test + @TestMetadata("referenceEnclosingClassFieldInReceiver.kt") + public void testReferenceEnclosingClassFieldInReceiver() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/referenceEnclosingClassFieldInReceiver.kt"); + } + + @Test + @TestMetadata("referenceEnclosingClassFieldInReceiver2.kt") + public void testReferenceEnclosingClassFieldInReceiver2() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/referenceEnclosingClassFieldInReceiver2.kt"); + } + + @Test + @TestMetadata("setAsExtensionFun.kt") + public void testSetAsExtensionFun() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/setAsExtensionFun.kt"); + } + + @Test + @TestMetadata("setAsExtensionFunInClass.kt") + public void testSetAsExtensionFunInClass() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/setAsExtensionFunInClass.kt"); + } + + @Test + @TestMetadata("topLevelVal.kt") + public void testTopLevelVal() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/topLevelVal.kt"); + } + + @Test + @TestMetadata("topLevelVar.kt") + public void testTopLevelVar() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/topLevelVar.kt"); + } + + @Test + @TestMetadata("twoPropByOneDelegete.kt") + public void testTwoPropByOneDelegete() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/twoPropByOneDelegete.kt"); + } + + @Test + @TestMetadata("useKPropertyLater.kt") + public void testUseKPropertyLater() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/useKPropertyLater.kt"); + } + + @Test + @TestMetadata("valByMapDelegatedProperty.kt") + public void testValByMapDelegatedProperty() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/valByMapDelegatedProperty.kt"); + } + + @Test + @TestMetadata("valInInnerClass.kt") + public void testValInInnerClass() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/valInInnerClass.kt"); + } + + @Test + @TestMetadata("varInInnerClass.kt") + public void testVarInInnerClass() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/varInInnerClass.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/delegatedProperty/delegateToAnother") + @TestDataPath("$PROJECT_ROOT") + public class DelegateToAnother { + @Test + public void testAllFilesPresentInDelegateToAnother() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/delegateToAnother"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("custom.kt") + public void testCustom() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToAnother/custom.kt"); + } + + @Test + @TestMetadata("kt49793_companionObject.kt") + public void testKt49793_companionObject() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToAnother/kt49793_companionObject.kt"); + } + + @Test + @TestMetadata("kt49793_interfaceCompanionObject.kt") + public void testKt49793_interfaceCompanionObject() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToAnother/kt49793_interfaceCompanionObject.kt"); + } + + @Test + @TestMetadata("kt49793_object.kt") + public void testKt49793_object() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToAnother/kt49793_object.kt"); + } + + @Test + @TestMetadata("kt50019_noOptimizedCallableReferences.kt") + public void testKt50019_noOptimizedCallableReferences() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToAnother/kt50019_noOptimizedCallableReferences.kt"); + } + + @Test + @TestMetadata("mutable.kt") + public void testMutable() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToAnother/mutable.kt"); + } + + @Test + @TestMetadata("openProperty.kt") + public void testOpenProperty() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToAnother/openProperty.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToAnother/simple.kt"); + } + + @Test + @TestMetadata("withSideEffects.kt") + public void testWithSideEffects() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToAnother/withSideEffects.kt"); + } + + @Test + @TestMetadata("withSideEffectsFromFileClass.kt") + public void testWithSideEffectsFromFileClass() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToAnother/withSideEffectsFromFileClass.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/delegatedProperty/delegateToConst") + @TestDataPath("$PROJECT_ROOT") + public class DelegateToConst { + @Test + public void testAllFilesPresentInDelegateToConst() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/delegateToConst"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("delegateToConst.kt") + public void testDelegateToConst() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToConst/delegateToConst.kt"); + } + + @Test + @TestMetadata("delegateToConstProperty.kt") + public void testDelegateToConstProperty() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToConst/delegateToConstProperty.kt"); + } + + @Test + @TestMetadata("delegateToNull.kt") + public void testDelegateToNull() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToConst/delegateToNull.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/delegatedProperty/delegateToFinalProperty") + @TestDataPath("$PROJECT_ROOT") + public class DelegateToFinalProperty { + @Test + public void testAllFilesPresentInDelegateToFinalProperty() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/delegateToFinalProperty"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("chain.kt") + public void testChain() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToFinalProperty/chain.kt"); + } + + @Test + @TestMetadata("delegateToFinalInstanceProperty.kt") + public void testDelegateToFinalInstanceProperty() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToFinalProperty/delegateToFinalInstanceProperty.kt"); + } + + @Test + @TestMetadata("delegateToFinalObjectProperty.kt") + public void testDelegateToFinalObjectProperty() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToFinalProperty/delegateToFinalObjectProperty.kt"); + } + + @Test + @TestMetadata("delegateToFinalProperty.kt") + public void testDelegateToFinalProperty() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToFinalProperty/delegateToFinalProperty.kt"); + } + + @Test + @TestMetadata("finalPropertyInAnotherFile.kt") + public void testFinalPropertyInAnotherFile() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToFinalProperty/finalPropertyInAnotherFile.kt"); + } + + @Test + @TestMetadata("initializeContainerOfTopLevelProperties.kt") + public void testInitializeContainerOfTopLevelProperties() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToFinalProperty/initializeContainerOfTopLevelProperties.kt"); + } + + @Test + @TestMetadata("memberExtensionPropertyAndImportFromObject.kt") + public void testMemberExtensionPropertyAndImportFromObject() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToFinalProperty/memberExtensionPropertyAndImportFromObject.kt"); + } + + @Test + @TestMetadata("memberExtensionPropertyAndLocalDelegatedProperty.kt") + public void testMemberExtensionPropertyAndLocalDelegatedProperty() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToFinalProperty/memberExtensionPropertyAndLocalDelegatedProperty.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/delegatedProperty/delegateToSingleton") + @TestDataPath("$PROJECT_ROOT") + public class DelegateToSingleton { + @Test + public void testAllFilesPresentInDelegateToSingleton() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/delegateToSingleton"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("delegateToEnum.kt") + public void testDelegateToEnum() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToSingleton/delegateToEnum.kt"); + } + + @Test + @TestMetadata("delegateToEnumInAClass.kt") + public void testDelegateToEnumInAClass() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToSingleton/delegateToEnumInAClass.kt"); + } + + @Test + @TestMetadata("delegateToSingleton.kt") + public void testDelegateToSingleton() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToSingleton/delegateToSingleton.kt"); + } + + @Test + @TestMetadata("noInitializationOfOuterClass.kt") + public void testNoInitializationOfOuterClass() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToSingleton/noInitializationOfOuterClass.kt"); + } + + @Test + @TestMetadata("withSideEffects.kt") + public void testWithSideEffects() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToSingleton/withSideEffects.kt"); + } + + @Test + @TestMetadata("withSideEffectsFromFileClass.kt") + public void testWithSideEffectsFromFileClass() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToSingleton/withSideEffectsFromFileClass.kt"); + } + + @Test + @TestMetadata("withSideEffectsToEnum.kt") + public void testWithSideEffectsToEnum() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToSingleton/withSideEffectsToEnum.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/delegatedProperty/delegateToThis") + @TestDataPath("$PROJECT_ROOT") + public class DelegateToThis { + @Test + public void testAllFilesPresentInDelegateToThis() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/delegateToThis"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("delegateToOuterThis.kt") + public void testDelegateToOuterThis() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToThis/delegateToOuterThis.kt"); + } + + @Test + @TestMetadata("delegateToThis.kt") + public void testDelegateToThis() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToThis/delegateToThis.kt"); + } + + @Test + @TestMetadata("delegateToThisByExtension.kt") + public void testDelegateToThisByExtension() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/delegateToThis/delegateToThisByExtension.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/delegatedProperty/local") + @TestDataPath("$PROJECT_ROOT") + public class Local { + @Test + public void testAllFilesPresentInLocal() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/local"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("capturedLocalVal.kt") + public void testCapturedLocalVal() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/local/capturedLocalVal.kt"); + } + + @Test + @TestMetadata("capturedLocalValNoInline.kt") + public void testCapturedLocalValNoInline() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/local/capturedLocalValNoInline.kt"); + } + + @Test + @TestMetadata("capturedLocalVar.kt") + public void testCapturedLocalVar() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/local/capturedLocalVar.kt"); + } + + @Test + @TestMetadata("capturedLocalVarNoInline.kt") + public void testCapturedLocalVarNoInline() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/local/capturedLocalVarNoInline.kt"); + } + + @Test + @TestMetadata("inlineGetValue.kt") + public void testInlineGetValue() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/local/inlineGetValue.kt"); + } + + @Test + @TestMetadata("inlineOperators.kt") + public void testInlineOperators() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/local/inlineOperators.kt"); + } + + @Test + @TestMetadata("kt12891.kt") + public void testKt12891() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/local/kt12891.kt"); + } + + @Test + @TestMetadata("kt13557.kt") + public void testKt13557() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/local/kt13557.kt"); + } + + @Test + @TestMetadata("kt16864.kt") + public void testKt16864() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/local/kt16864.kt"); + } + + @Test + @TestMetadata("kt19690.kt") + public void testKt19690() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/local/kt19690.kt"); + } + + @Test + @TestMetadata("kt21085.kt") + public void testKt21085() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/local/kt21085.kt"); + } + + @Test + @TestMetadata("kt23117.kt") + public void testKt23117() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/local/kt23117.kt"); + } + + @Test + @TestMetadata("localVal.kt") + public void testLocalVal() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/local/localVal.kt"); + } + + @Test + @TestMetadata("localValNoExplicitType.kt") + public void testLocalValNoExplicitType() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/local/localValNoExplicitType.kt"); + } + + @Test + @TestMetadata("localVar.kt") + public void testLocalVar() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/local/localVar.kt"); + } + + @Test + @TestMetadata("localVarNoExplicitType.kt") + public void testLocalVarNoExplicitType() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/local/localVarNoExplicitType.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties") + @TestDataPath("$PROJECT_ROOT") + public class OptimizedDelegatedProperties { + @Test + public void testAllFilesPresentInOptimizedDelegatedProperties() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("definedInSources.kt") + public void testDefinedInSources() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties/definedInSources.kt"); + } + + @Test + @TestMetadata("definedInSourcesWithNonNullParameter.kt") + public void testDefinedInSourcesWithNonNullParameter() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties/definedInSourcesWithNonNullParameter.kt"); + } + + @Test + @TestMetadata("inSeparateModule.kt") + public void testInSeparateModule() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties/inSeparateModule.kt"); + } + + @Test + @TestMetadata("inSeparateModuleWithNonNullParameter.kt") + public void testInSeparateModuleWithNonNullParameter() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties/inSeparateModuleWithNonNullParameter.kt"); + } + + @Test + @TestMetadata("kt40815.kt") + public void testKt40815() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties/kt40815.kt"); + } + + @Test + @TestMetadata("kt40815_2.kt") + public void testKt40815_2() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties/kt40815_2.kt"); + } + + @Test + @TestMetadata("kt40815_3.kt") + public void testKt40815_3() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties/kt40815_3.kt"); + } + + @Test + @TestMetadata("kt42253.kt") + public void testKt42253() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties/kt42253.kt"); + } + + @Test + @TestMetadata("kt48825.kt") + public void testKt48825() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties/kt48825.kt"); + } + + @Test + @TestMetadata("lazy.kt") + public void testLazy() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties/lazy.kt"); + } + + @Test + @TestMetadata("mixedArgumentSizes.kt") + public void testMixedArgumentSizes() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/optimizedDelegatedProperties/mixedArgumentSizes.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/delegatedProperty/provideDelegate") + @TestDataPath("$PROJECT_ROOT") + public class ProvideDelegate { + @Test + public void testAllFilesPresentInProvideDelegate() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegatedProperty/provideDelegate"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("delegatedPropertyWithIdProvideDelegate.kt") + public void testDelegatedPropertyWithIdProvideDelegate() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/delegatedPropertyWithIdProvideDelegate.kt"); + } + + @Test + @TestMetadata("differentReceivers.kt") + public void testDifferentReceivers() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/differentReceivers.kt"); + } + + @Test + @TestMetadata("evaluationOrder.kt") + public void testEvaluationOrder() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/evaluationOrder.kt"); + } + + @Test + @TestMetadata("evaluationOrderVar.kt") + public void testEvaluationOrderVar() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/evaluationOrderVar.kt"); + } + + @Test + @TestMetadata("extensionDelegated.kt") + public void testExtensionDelegated() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/extensionDelegated.kt"); + } + + @Test + @TestMetadata("generic.kt") + public void testGeneric() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/generic.kt"); + } + + @Test + @TestMetadata("genericDelegateWithNoAdditionalInfo.kt") + public void testGenericDelegateWithNoAdditionalInfo() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/genericDelegateWithNoAdditionalInfo.kt"); + } + + @Test + @TestMetadata("genericProvideDelegateOnNumberLiteral.kt") + public void testGenericProvideDelegateOnNumberLiteral() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/genericProvideDelegateOnNumberLiteral.kt"); + } + + @Test + @TestMetadata("hostCheck.kt") + public void testHostCheck() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/hostCheck.kt"); + } + + @Test + @TestMetadata("inClass.kt") + public void testInClass() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/inClass.kt"); + } + + @Test + @TestMetadata("inlineProvideDelegate.kt") + public void testInlineProvideDelegate() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/inlineProvideDelegate.kt"); + } + + @Test + @TestMetadata("kt15437.kt") + public void testKt15437() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/kt15437.kt"); + } + + @Test + @TestMetadata("kt16441.kt") + public void testKt16441() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/kt16441.kt"); + } + + @Test + @TestMetadata("kt18902.kt") + public void testKt18902() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/kt18902.kt"); + } + + @Test + @TestMetadata("kt39588.kt") + public void testKt39588() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/kt39588.kt"); + } + + @Test + @TestMetadata("local.kt") + public void testLocal() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/local.kt"); + } + + @Test + @TestMetadata("localCaptured.kt") + public void testLocalCaptured() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/localCaptured.kt"); + } + + @Test + @TestMetadata("localDifferentReceivers.kt") + public void testLocalDifferentReceivers() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/localDifferentReceivers.kt"); + } + + @Test + @TestMetadata("memberExtension.kt") + public void testMemberExtension() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/memberExtension.kt"); + } + + @Test + @TestMetadata("propertyMetadata.kt") + public void testPropertyMetadata() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/propertyMetadata.kt"); + } + + @Test + @TestMetadata("provideDelegateByExtensionFunction.kt") + public void testProvideDelegateByExtensionFunction() throws Exception { + runTest("compiler/testData/codegen/box/delegatedProperty/provideDelegate/provideDelegateByExtensionFunction.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/delegation") + @TestDataPath("$PROJECT_ROOT") + public class Delegation { + @Test + public void testAllFilesPresentInDelegation() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/delegation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("delegationDifferentModule.kt") + public void testDelegationDifferentModule() throws Exception { + runTest("compiler/testData/codegen/box/delegation/delegationDifferentModule.kt"); + } + + @Test + @TestMetadata("delegationDifferentModule2.kt") + public void testDelegationDifferentModule2() throws Exception { + runTest("compiler/testData/codegen/box/delegation/delegationDifferentModule2.kt"); + } + + @Test + @TestMetadata("delegationToIntersectionType.kt") + public void testDelegationToIntersectionType() throws Exception { + runTest("compiler/testData/codegen/box/delegation/delegationToIntersectionType.kt"); + } + + @Test + @TestMetadata("delegationWithPrivateConstructor.kt") + public void testDelegationWithPrivateConstructor() throws Exception { + runTest("compiler/testData/codegen/box/delegation/delegationWithPrivateConstructor.kt"); + } + + @Test + @TestMetadata("genericProperty.kt") + public void testGenericProperty() throws Exception { + runTest("compiler/testData/codegen/box/delegation/genericProperty.kt"); + } + + @Test + @TestMetadata("hiddenSuperOverrideIn1.0.kt") + public void testHiddenSuperOverrideIn1_0() throws Exception { + runTest("compiler/testData/codegen/box/delegation/hiddenSuperOverrideIn1.0.kt"); + } + + @Test + @TestMetadata("inDataClass.kt") + public void testInDataClass() throws Exception { + runTest("compiler/testData/codegen/box/delegation/inDataClass.kt"); + } + + @Test + @TestMetadata("kt30102_comparable.kt") + public void testKt30102_comparable() throws Exception { + runTest("compiler/testData/codegen/box/delegation/kt30102_comparable.kt"); + } + + @Test + @TestMetadata("kt8154.kt") + public void testKt8154() throws Exception { + runTest("compiler/testData/codegen/box/delegation/kt8154.kt"); + } + + @Test + @TestMetadata("smartCastedDelegation.kt") + public void testSmartCastedDelegation() throws Exception { + runTest("compiler/testData/codegen/box/delegation/smartCastedDelegation.kt"); + } + + @Test + @TestMetadata("viaTypeAlias.kt") + public void testViaTypeAlias() throws Exception { + runTest("compiler/testData/codegen/box/delegation/viaTypeAlias.kt"); + } + + @Test + @TestMetadata("withDefaultParameters.kt") + public void testWithDefaultParameters() throws Exception { + runTest("compiler/testData/codegen/box/delegation/withDefaultParameters.kt"); + } + + @Test + @TestMetadata("withDefaultsMultipleFilesOrder.kt") + public void testWithDefaultsMultipleFilesOrder() throws Exception { + runTest("compiler/testData/codegen/box/delegation/withDefaultsMultipleFilesOrder.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/deprecated") + @TestDataPath("$PROJECT_ROOT") + public class Deprecated { + @Test + public void testAllFilesPresentInDeprecated() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/deprecated"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/destructuringDeclInLambdaParam") + @TestDataPath("$PROJECT_ROOT") + public class DestructuringDeclInLambdaParam { + @Test + public void testAllFilesPresentInDestructuringDeclInLambdaParam() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/destructuringDeclInLambdaParam"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("extensionComponents.kt") + public void testExtensionComponents() throws Exception { + runTest("compiler/testData/codegen/box/destructuringDeclInLambdaParam/extensionComponents.kt"); + } + + @Test + @TestMetadata("generic.kt") + public void testGeneric() throws Exception { + runTest("compiler/testData/codegen/box/destructuringDeclInLambdaParam/generic.kt"); + } + + @Test + @TestMetadata("inline.kt") + public void testInline() throws Exception { + runTest("compiler/testData/codegen/box/destructuringDeclInLambdaParam/inline.kt"); + } + + @Test + @TestMetadata("otherParameters.kt") + public void testOtherParameters() throws Exception { + runTest("compiler/testData/codegen/box/destructuringDeclInLambdaParam/otherParameters.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/destructuringDeclInLambdaParam/simple.kt"); + } + + @Test + @TestMetadata("stdlibUsages.kt") + public void testStdlibUsages() throws Exception { + runTest("compiler/testData/codegen/box/destructuringDeclInLambdaParam/stdlibUsages.kt"); + } + + @Test + @TestMetadata("underscoreNames.kt") + public void testUnderscoreNames() throws Exception { + runTest("compiler/testData/codegen/box/destructuringDeclInLambdaParam/underscoreNames.kt"); + } + + @Test + @TestMetadata("withIndexed.kt") + public void testWithIndexed() throws Exception { + runTest("compiler/testData/codegen/box/destructuringDeclInLambdaParam/withIndexed.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/diagnostics") + @TestDataPath("$PROJECT_ROOT") + public class Diagnostics { + @Test + public void testAllFilesPresentInDiagnostics() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/diagnostics/functions") + @TestDataPath("$PROJECT_ROOT") + public class Functions { + @Test + public void testAllFilesPresentInFunctions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/inference") + @TestDataPath("$PROJECT_ROOT") + public class Inference { + @Test + public void testAllFilesPresentInInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/inference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt6176.kt") + public void testKt6176() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/inference/kt6176.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/invoke") + @TestDataPath("$PROJECT_ROOT") + public class Invoke { + @Test + public void testAllFilesPresentInInvoke() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects") + @TestDataPath("$PROJECT_ROOT") + public class OnObjects { + @Test + public void testAllFilesPresentInOnObjects() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("invokeOnClassObject1.kt") + public void testInvokeOnClassObject1() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnClassObject1.kt"); + } + + @Test + @TestMetadata("invokeOnClassObject2.kt") + public void testInvokeOnClassObject2() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnClassObject2.kt"); + } + + @Test + @TestMetadata("invokeOnClassObjectOfNestedClass1.kt") + public void testInvokeOnClassObjectOfNestedClass1() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnClassObjectOfNestedClass1.kt"); + } + + @Test + @TestMetadata("invokeOnClassObjectOfNestedClass2.kt") + public void testInvokeOnClassObjectOfNestedClass2() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnClassObjectOfNestedClass2.kt"); + } + + @Test + @TestMetadata("invokeOnEnum1.kt") + public void testInvokeOnEnum1() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnEnum1.kt"); + } + + @Test + @TestMetadata("invokeOnEnum2.kt") + public void testInvokeOnEnum2() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnEnum2.kt"); + } + + @Test + @TestMetadata("invokeOnImportedEnum1.kt") + public void testInvokeOnImportedEnum1() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnImportedEnum1.kt"); + } + + @Test + @TestMetadata("invokeOnImportedEnum2.kt") + public void testInvokeOnImportedEnum2() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnImportedEnum2.kt"); + } + + @Test + @TestMetadata("invokeOnObject1.kt") + public void testInvokeOnObject1() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnObject1.kt"); + } + + @Test + @TestMetadata("invokeOnObject2.kt") + public void testInvokeOnObject2() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/invoke/onObjects/invokeOnObject2.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/diagnostics/functions/tailRecursion") + @TestDataPath("$PROJECT_ROOT") + public class TailRecursion { + @Test + public void testAllFilesPresentInTailRecursion() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/functions/tailRecursion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("defaultArgs.kt") + public void testDefaultArgs() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/defaultArgs.kt"); + } + + @Test + @TestMetadata("defaultArgs2.kt") + public void testDefaultArgs2() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/defaultArgs2.kt"); + } + + @Test + @TestMetadata("defaultArgsOverridden.kt") + public void testDefaultArgsOverridden() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/defaultArgsOverridden.kt"); + } + + @Test + @TestMetadata("defaultArgsWithSideEffects.kt") + public void testDefaultArgsWithSideEffects() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/defaultArgsWithSideEffects.kt"); + } + + @Test + @TestMetadata("defaultArgsWithSideEffects2.kt") + public void testDefaultArgsWithSideEffects2() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/defaultArgsWithSideEffects2.kt"); + } + + @Test + @TestMetadata("extensionTailCall.kt") + public void testExtensionTailCall() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/extensionTailCall.kt"); + } + + @Test + @TestMetadata("functionWithNoTails.kt") + public void testFunctionWithNoTails() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/functionWithNoTails.kt"); + } + + @Test + @TestMetadata("functionWithNonTailRecursions.kt") + public void testFunctionWithNonTailRecursions() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/functionWithNonTailRecursions.kt"); + } + + @Test + @TestMetadata("functionWithoutAnnotation.kt") + public void testFunctionWithoutAnnotation() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/functionWithoutAnnotation.kt"); + } + + @Test + @TestMetadata("infixCall.kt") + public void testInfixCall() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/infixCall.kt"); + } + + @Test + @TestMetadata("infixRecursiveCall.kt") + public void testInfixRecursiveCall() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/infixRecursiveCall.kt"); + } + + @Test + @TestMetadata("insideElvis.kt") + public void testInsideElvis() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/insideElvis.kt"); + } + + @Test + @TestMetadata("kt47084_lambdaInDefaultArgument.kt") + public void testKt47084_lambdaInDefaultArgument() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/kt47084_lambdaInDefaultArgument.kt"); + } + + @Test + @TestMetadata("labeledThisReferences.kt") + public void testLabeledThisReferences() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/labeledThisReferences.kt"); + } + + @Test + @TestMetadata("loops.kt") + public void testLoops() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/loops.kt"); + } + + @Test + @TestMetadata("multilevelBlocks.kt") + public void testMultilevelBlocks() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/multilevelBlocks.kt"); + } + + @Test + @TestMetadata("realIteratorFoldl.kt") + public void testRealIteratorFoldl() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/realIteratorFoldl.kt"); + } + + @Test + @TestMetadata("realStringEscape.kt") + public void testRealStringEscape() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/realStringEscape.kt"); + } + + @Test + @TestMetadata("realStringRepeat.kt") + public void testRealStringRepeat() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/realStringRepeat.kt"); + } + + @Test + @TestMetadata("recursiveCallInInlineLambda.kt") + public void testRecursiveCallInInlineLambda() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/recursiveCallInInlineLambda.kt"); + } + + @Test + @TestMetadata("recursiveCallInInlineLambdaWithCapture.kt") + public void testRecursiveCallInInlineLambdaWithCapture() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/recursiveCallInInlineLambdaWithCapture.kt"); + } + + @Test + @TestMetadata("recursiveCallInLambda.kt") + public void testRecursiveCallInLambda() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/recursiveCallInLambda.kt"); + } + + @Test + @TestMetadata("recursiveCallInLocalFunction.kt") + public void testRecursiveCallInLocalFunction() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/recursiveCallInLocalFunction.kt"); + } + + @Test + @TestMetadata("recursiveInnerFunction.kt") + public void testRecursiveInnerFunction() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/recursiveInnerFunction.kt"); + } + + @Test + @TestMetadata("returnIf.kt") + public void testReturnIf() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnIf.kt"); + } + + @Test + @TestMetadata("returnInCatch.kt") + public void testReturnInCatch() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInCatch.kt"); + } + + @Test + @TestMetadata("returnInFinally.kt") + public void testReturnInFinally() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInFinally.kt"); + } + + @Test + @TestMetadata("returnInIfInFinally.kt") + public void testReturnInIfInFinally() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInIfInFinally.kt"); + } + + @Test + @TestMetadata("returnInParentheses.kt") + public void testReturnInParentheses() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInParentheses.kt"); + } + + @Test + @TestMetadata("returnInTry.kt") + public void testReturnInTry() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInTry.kt"); + } + + @Test + @TestMetadata("simpleBlock.kt") + public void testSimpleBlock() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/simpleBlock.kt"); + } + + @Test + @TestMetadata("simpleReturn.kt") + public void testSimpleReturn() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/simpleReturn.kt"); + } + + @Test + @TestMetadata("simpleReturnWithElse.kt") + public void testSimpleReturnWithElse() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/simpleReturnWithElse.kt"); + } + + @Test + @TestMetadata("sum.kt") + public void testSum() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/sum.kt"); + } + + @Test + @TestMetadata("tailCallInBlockInParentheses.kt") + public void testTailCallInBlockInParentheses() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/tailCallInBlockInParentheses.kt"); + } + + @Test + @TestMetadata("tailCallInParentheses.kt") + public void testTailCallInParentheses() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/tailCallInParentheses.kt"); + } + + @Test + @TestMetadata("tailRecursionInFinally.kt") + public void testTailRecursionInFinally() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/tailRecursionInFinally.kt"); + } + + @Test + @TestMetadata("tailrecWithExplicitCompanionObjectDispatcher.kt") + public void testTailrecWithExplicitCompanionObjectDispatcher() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/tailrecWithExplicitCompanionObjectDispatcher.kt"); + } + + @Test + @TestMetadata("tailrecWithExplicitObjectDispatcher.kt") + public void testTailrecWithExplicitObjectDispatcher() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/tailrecWithExplicitObjectDispatcher.kt"); + } + + @Test + @TestMetadata("thisReferences.kt") + public void testThisReferences() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/thisReferences.kt"); + } + + @Test + @TestMetadata("unitBlocks.kt") + public void testUnitBlocks() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/unitBlocks.kt"); + } + + @Test + @TestMetadata("whenWithCondition.kt") + public void testWhenWithCondition() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithCondition.kt"); + } + + @Test + @TestMetadata("whenWithInRange.kt") + public void testWhenWithInRange() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithInRange.kt"); + } + + @Test + @TestMetadata("whenWithIs.kt") + public void testWhenWithIs() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithIs.kt"); + } + + @Test + @TestMetadata("whenWithoutCondition.kt") + public void testWhenWithoutCondition() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithoutCondition.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/diagnostics/vararg") + @TestDataPath("$PROJECT_ROOT") + public class Vararg { + @Test + public void testAllFilesPresentInVararg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/diagnostics/vararg"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt4172.kt") + public void testKt4172() throws Exception { + runTest("compiler/testData/codegen/box/diagnostics/vararg/kt4172.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/differentDependencyVersion") + @TestDataPath("$PROJECT_ROOT") + public class DifferentDependencyVersion { + @Test + public void testAllFilesPresentInDifferentDependencyVersion() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/differentDependencyVersion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/directInvokeOptimization") + @TestDataPath("$PROJECT_ROOT") + public class DirectInvokeOptimization { + @Test + public void testAllFilesPresentInDirectInvokeOptimization() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/directInvokeOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("boundInnerContructorRef.kt") + public void testBoundInnerContructorRef() throws Exception { + runTest("compiler/testData/codegen/box/directInvokeOptimization/boundInnerContructorRef.kt"); + } + + @Test + @TestMetadata("boundMemberRef.kt") + public void testBoundMemberRef() throws Exception { + runTest("compiler/testData/codegen/box/directInvokeOptimization/boundMemberRef.kt"); + } + + @Test + @TestMetadata("canary.kt") + public void testCanary() throws Exception { + runTest("compiler/testData/codegen/box/directInvokeOptimization/canary.kt"); + } + + @Test + @TestMetadata("capturingLambda.kt") + public void testCapturingLambda() throws Exception { + runTest("compiler/testData/codegen/box/directInvokeOptimization/capturingLambda.kt"); + } + + @Test + @TestMetadata("contructorRef.kt") + public void testContructorRef() throws Exception { + runTest("compiler/testData/codegen/box/directInvokeOptimization/contructorRef.kt"); + } + + @Test + @TestMetadata("kt53202.kt") + public void testKt53202() throws Exception { + runTest("compiler/testData/codegen/box/directInvokeOptimization/kt53202.kt"); + } + + @Test + @TestMetadata("kt53202_funLiteral.kt") + public void testKt53202_funLiteral() throws Exception { + runTest("compiler/testData/codegen/box/directInvokeOptimization/kt53202_funLiteral.kt"); + } + + @Test + @TestMetadata("kt53202_returns.kt") + public void testKt53202_returns() throws Exception { + runTest("compiler/testData/codegen/box/directInvokeOptimization/kt53202_returns.kt"); + } + + @Test + @TestMetadata("nestedLambdas.kt") + public void testNestedLambdas() throws Exception { + runTest("compiler/testData/codegen/box/directInvokeOptimization/nestedLambdas.kt"); + } + + @Test + @TestMetadata("simpleAnonymousFun.kt") + public void testSimpleAnonymousFun() throws Exception { + runTest("compiler/testData/codegen/box/directInvokeOptimization/simpleAnonymousFun.kt"); + } + + @Test + @TestMetadata("simpleFunRef.kt") + public void testSimpleFunRef() throws Exception { + runTest("compiler/testData/codegen/box/directInvokeOptimization/simpleFunRef.kt"); + } + + @Test + @TestMetadata("simpleLambda.kt") + public void testSimpleLambda() throws Exception { + runTest("compiler/testData/codegen/box/directInvokeOptimization/simpleLambda.kt"); + } + + @Test + @TestMetadata("unboundInnerContructorRef.kt") + public void testUnboundInnerContructorRef() throws Exception { + runTest("compiler/testData/codegen/box/directInvokeOptimization/unboundInnerContructorRef.kt"); + } + + @Test + @TestMetadata("unboundMemberRef.kt") + public void testUnboundMemberRef() throws Exception { + runTest("compiler/testData/codegen/box/directInvokeOptimization/unboundMemberRef.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/elvis") + @TestDataPath("$PROJECT_ROOT") + public class Elvis { + @Test + public void testAllFilesPresentInElvis() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/elvis"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("genericElvisWithMoreSpecificLHS.kt") + public void testGenericElvisWithMoreSpecificLHS() throws Exception { + runTest("compiler/testData/codegen/box/elvis/genericElvisWithMoreSpecificLHS.kt"); + } + + @Test + @TestMetadata("genericElvisWithNullLHS.kt") + public void testGenericElvisWithNullLHS() throws Exception { + runTest("compiler/testData/codegen/box/elvis/genericElvisWithNullLHS.kt"); + } + + @Test + @TestMetadata("genericNull.kt") + public void testGenericNull() throws Exception { + runTest("compiler/testData/codegen/box/elvis/genericNull.kt"); + } + + @Test + @TestMetadata("kt24209.kt") + public void testKt24209() throws Exception { + runTest("compiler/testData/codegen/box/elvis/kt24209.kt"); + } + + @Test + @TestMetadata("kt6694ExactAnnotationForElvis.kt") + public void testKt6694ExactAnnotationForElvis() throws Exception { + runTest("compiler/testData/codegen/box/elvis/kt6694ExactAnnotationForElvis.kt"); + } + + @Test + @TestMetadata("nullNullOk.kt") + public void testNullNullOk() throws Exception { + runTest("compiler/testData/codegen/box/elvis/nullNullOk.kt"); + } + + @Test + @TestMetadata("ofNonNullableResultType.kt") + public void testOfNonNullableResultType() throws Exception { + runTest("compiler/testData/codegen/box/elvis/ofNonNullableResultType.kt"); + } + + @Test + @TestMetadata("primitive.kt") + public void testPrimitive() throws Exception { + runTest("compiler/testData/codegen/box/elvis/primitive.kt"); + } + + @Test + @TestMetadata("withReturn.kt") + public void testWithReturn() throws Exception { + runTest("compiler/testData/codegen/box/elvis/withReturn.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/enum") + @TestDataPath("$PROJECT_ROOT") + public class Enum { + @Test + @TestMetadata("abstractMethodInEnum.kt") + public void testAbstractMethodInEnum() throws Exception { + runTest("compiler/testData/codegen/box/enum/abstractMethodInEnum.kt"); + } + + @Test + @TestMetadata("abstractNestedClass.kt") + public void testAbstractNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/enum/abstractNestedClass.kt"); + } + + @Test + public void testAllFilesPresentInEnum() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("asReturnExpression.kt") + public void testAsReturnExpression() throws Exception { + runTest("compiler/testData/codegen/box/enum/asReturnExpression.kt"); + } + + @Test + @TestMetadata("companionAccessingEnumValue.kt") + public void testCompanionAccessingEnumValue() throws Exception { + runTest("compiler/testData/codegen/box/enum/companionAccessingEnumValue.kt"); + } + + @Test + @TestMetadata("companionObjectInEnum.kt") + public void testCompanionObjectInEnum() throws Exception { + runTest("compiler/testData/codegen/box/enum/companionObjectInEnum.kt"); + } + + @Test + @TestMetadata("constructorWithReordering.kt") + public void testConstructorWithReordering() throws Exception { + runTest("compiler/testData/codegen/box/enum/constructorWithReordering.kt"); + } + + @Test + @TestMetadata("deepInnerClassInEnumEntryClass.kt") + public void testDeepInnerClassInEnumEntryClass() throws Exception { + runTest("compiler/testData/codegen/box/enum/deepInnerClassInEnumEntryClass.kt"); + } + + @Test + @TestMetadata("deepInnerClassInEnumEntryClass2.kt") + public void testDeepInnerClassInEnumEntryClass2() throws Exception { + runTest("compiler/testData/codegen/box/enum/deepInnerClassInEnumEntryClass2.kt"); + } + + @Test + @TestMetadata("emptyConstructor.kt") + public void testEmptyConstructor() throws Exception { + runTest("compiler/testData/codegen/box/enum/emptyConstructor.kt"); + } + + @Test + @TestMetadata("emptyEnumValuesValueOf.kt") + public void testEmptyEnumValuesValueOf() throws Exception { + runTest("compiler/testData/codegen/box/enum/emptyEnumValuesValueOf.kt"); + } + + @Test + @TestMetadata("enumCompanionInitJsAndWasm.kt") + public void testEnumCompanionInitJsAndWasm() throws Exception { + runTest("compiler/testData/codegen/box/enum/enumCompanionInitJsAndWasm.kt"); + } + + @Test + @TestMetadata("enumConstructorParameterClashWithDefaults.kt") + public void testEnumConstructorParameterClashWithDefaults() throws Exception { + runTest("compiler/testData/codegen/box/enum/enumConstructorParameterClashWithDefaults.kt"); + } + + @Test + @TestMetadata("enumEntries.kt") + public void testEnumEntries() throws Exception { + runTest("compiler/testData/codegen/box/enum/enumEntries.kt"); + } + + @Test + @TestMetadata("enumEntriesCompatibilityCheck.kt") + public void testEnumEntriesCompatibilityCheck() throws Exception { + runTest("compiler/testData/codegen/box/enum/enumEntriesCompatibilityCheck.kt"); + } + + @Test + @TestMetadata("enumEntriesInCompanion.kt") + public void testEnumEntriesInCompanion() throws Exception { + runTest("compiler/testData/codegen/box/enum/enumEntriesInCompanion.kt"); + } + + @Test + @TestMetadata("enumEntriesMultimoduleNoMappings.kt") + public void testEnumEntriesMultimoduleNoMappings() throws Exception { + runTest("compiler/testData/codegen/box/enum/enumEntriesMultimoduleNoMappings.kt"); + } + + @Test + @TestMetadata("enumEntriesNameClashes.kt") + public void testEnumEntriesNameClashes() throws Exception { + runTest("compiler/testData/codegen/box/enum/enumEntriesNameClashes.kt"); + } + + @Test + @TestMetadata("enumEntryHashCode.kt") + public void testEnumEntryHashCode() throws Exception { + runTest("compiler/testData/codegen/box/enum/enumEntryHashCode.kt"); + } + + @Test + @TestMetadata("enumEntryMembers.kt") + public void testEnumEntryMembers() throws Exception { + runTest("compiler/testData/codegen/box/enum/enumEntryMembers.kt"); + } + + @Test + @TestMetadata("enumEntryReferenceFromInnerClassConstructor1.kt") + public void testEnumEntryReferenceFromInnerClassConstructor1() throws Exception { + runTest("compiler/testData/codegen/box/enum/enumEntryReferenceFromInnerClassConstructor1.kt"); + } + + @Test + @TestMetadata("enumEntryReferenceFromInnerClassConstructor2.kt") + public void testEnumEntryReferenceFromInnerClassConstructor2() throws Exception { + runTest("compiler/testData/codegen/box/enum/enumEntryReferenceFromInnerClassConstructor2.kt"); + } + + @Test + @TestMetadata("enumEntryReferenceFromInnerClassConstructor3.kt") + public void testEnumEntryReferenceFromInnerClassConstructor3() throws Exception { + runTest("compiler/testData/codegen/box/enum/enumEntryReferenceFromInnerClassConstructor3.kt"); + } + + @Test + @TestMetadata("enumInheritedFromTrait.kt") + public void testEnumInheritedFromTrait() throws Exception { + runTest("compiler/testData/codegen/box/enum/enumInheritedFromTrait.kt"); + } + + @Test + @TestMetadata("enumMultiModule.kt") + public void testEnumMultiModule() throws Exception { + runTest("compiler/testData/codegen/box/enum/enumMultiModule.kt"); + } + + @Test + @TestMetadata("enumShort.kt") + public void testEnumShort() throws Exception { + runTest("compiler/testData/codegen/box/enum/enumShort.kt"); + } + + @Test + @TestMetadata("enumValueOf.kt") + public void testEnumValueOf() throws Exception { + runTest("compiler/testData/codegen/box/enum/enumValueOf.kt"); + } + + @Test + @TestMetadata("enumWithLambdaParameter.kt") + public void testEnumWithLambdaParameter() throws Exception { + runTest("compiler/testData/codegen/box/enum/enumWithLambdaParameter.kt"); + } + + @Test + @TestMetadata("getEnumEntityByOrdinal.kt") + public void testGetEnumEntityByOrdinal() throws Exception { + runTest("compiler/testData/codegen/box/enum/getEnumEntityByOrdinal.kt"); + } + + @Test + @TestMetadata("inPackage.kt") + public void testInPackage() throws Exception { + runTest("compiler/testData/codegen/box/enum/inPackage.kt"); + } + + @Test + @TestMetadata("inclassobj.kt") + public void testInclassobj() throws Exception { + runTest("compiler/testData/codegen/box/enum/inclassobj.kt"); + } + + @Test + @TestMetadata("initEntriesInCompanionObject.kt") + public void testInitEntriesInCompanionObject() throws Exception { + runTest("compiler/testData/codegen/box/enum/initEntriesInCompanionObject.kt"); + } + + @Test + @TestMetadata("initEntriesInCompanionObject2.kt") + public void testInitEntriesInCompanionObject2() throws Exception { + runTest("compiler/testData/codegen/box/enum/initEntriesInCompanionObject2.kt"); + } + + @Test + @TestMetadata("initEntriesInValueOf.kt") + public void testInitEntriesInValueOf() throws Exception { + runTest("compiler/testData/codegen/box/enum/initEntriesInValueOf.kt"); + } + + @Test + @TestMetadata("initEnumAfterObjectAccessJsAndWasm.kt") + public void testInitEnumAfterObjectAccessJsAndWasm() throws Exception { + runTest("compiler/testData/codegen/box/enum/initEnumAfterObjectAccessJsAndWasm.kt"); + } + + @Test + @TestMetadata("inner.kt") + public void testInner() throws Exception { + runTest("compiler/testData/codegen/box/enum/inner.kt"); + } + + @Test + @TestMetadata("innerClassInEnumEntryClass.kt") + public void testInnerClassInEnumEntryClass() throws Exception { + runTest("compiler/testData/codegen/box/enum/innerClassInEnumEntryClass.kt"); + } + + @Test + @TestMetadata("innerClassMethodInEnumEntryClass.kt") + public void testInnerClassMethodInEnumEntryClass() throws Exception { + runTest("compiler/testData/codegen/box/enum/innerClassMethodInEnumEntryClass.kt"); + } + + @Test + @TestMetadata("innerClassMethodInEnumEntryClass2.kt") + public void testInnerClassMethodInEnumEntryClass2() throws Exception { + runTest("compiler/testData/codegen/box/enum/innerClassMethodInEnumEntryClass2.kt"); + } + + @Test + @TestMetadata("innerWithExistingClassObject.kt") + public void testInnerWithExistingClassObject() throws Exception { + runTest("compiler/testData/codegen/box/enum/innerWithExistingClassObject.kt"); + } + + @Test + @TestMetadata("k54079.kt") + public void testK54079() throws Exception { + runTest("compiler/testData/codegen/box/enum/k54079.kt"); + } + + @Test + @TestMetadata("kt1119.kt") + public void testKt1119() throws Exception { + runTest("compiler/testData/codegen/box/enum/kt1119.kt"); + } + + @Test + @TestMetadata("kt18731.kt") + public void testKt18731() throws Exception { + runTest("compiler/testData/codegen/box/enum/kt18731.kt"); + } + + @Test + @TestMetadata("kt18731_2.kt") + public void testKt18731_2() throws Exception { + runTest("compiler/testData/codegen/box/enum/kt18731_2.kt"); + } + + @Test + @TestMetadata("kt20651.kt") + public void testKt20651() throws Exception { + runTest("compiler/testData/codegen/box/enum/kt20651.kt"); + } + + @Test + @TestMetadata("kt20651_inlineLambda.kt") + public void testKt20651_inlineLambda() throws Exception { + runTest("compiler/testData/codegen/box/enum/kt20651_inlineLambda.kt"); + } + + @Test + @TestMetadata("kt20651a.kt") + public void testKt20651a() throws Exception { + runTest("compiler/testData/codegen/box/enum/kt20651a.kt"); + } + + @Test + @TestMetadata("kt20651b.kt") + public void testKt20651b() throws Exception { + runTest("compiler/testData/codegen/box/enum/kt20651b.kt"); + } + + @Test + @TestMetadata("kt2350.kt") + public void testKt2350() throws Exception { + runTest("compiler/testData/codegen/box/enum/kt2350.kt"); + } + + @Test + @TestMetadata("kt38996.kt") + public void testKt38996() throws Exception { + runTest("compiler/testData/codegen/box/enum/kt38996.kt"); + } + + @Test + @TestMetadata("kt44744.kt") + public void testKt44744() throws Exception { + runTest("compiler/testData/codegen/box/enum/kt44744.kt"); + } + + @Test + @TestMetadata("kt44744_innerClass.kt") + public void testKt44744_innerClass() throws Exception { + runTest("compiler/testData/codegen/box/enum/kt44744_innerClass.kt"); + } + + @Test + @TestMetadata("kt46605.kt") + public void testKt46605() throws Exception { + runTest("compiler/testData/codegen/box/enum/kt46605.kt"); + } + + @Test + @TestMetadata("kt7257.kt") + public void testKt7257() throws Exception { + runTest("compiler/testData/codegen/box/enum/kt7257.kt"); + } + + @Test + @TestMetadata("kt7257_anonObjectInit.kt") + public void testKt7257_anonObjectInit() throws Exception { + runTest("compiler/testData/codegen/box/enum/kt7257_anonObjectInit.kt"); + } + + @Test + @TestMetadata("kt7257_anonObjectMethod.kt") + public void testKt7257_anonObjectMethod() throws Exception { + runTest("compiler/testData/codegen/box/enum/kt7257_anonObjectMethod.kt"); + } + + @Test + @TestMetadata("kt7257_boundReference1.kt") + public void testKt7257_boundReference1() throws Exception { + runTest("compiler/testData/codegen/box/enum/kt7257_boundReference1.kt"); + } + + @Test + @TestMetadata("kt7257_boundReference2.kt") + public void testKt7257_boundReference2() throws Exception { + runTest("compiler/testData/codegen/box/enum/kt7257_boundReference2.kt"); + } + + @Test + @TestMetadata("kt7257_boundReferenceWithImplicitReceiver.kt") + public void testKt7257_boundReferenceWithImplicitReceiver() throws Exception { + runTest("compiler/testData/codegen/box/enum/kt7257_boundReferenceWithImplicitReceiver.kt"); + } + + @Test + @TestMetadata("kt7257_explicitReceiver.kt") + public void testKt7257_explicitReceiver() throws Exception { + runTest("compiler/testData/codegen/box/enum/kt7257_explicitReceiver.kt"); + } + + @Test + @TestMetadata("kt7257_fullyQualifiedReceiver.kt") + public void testKt7257_fullyQualifiedReceiver() throws Exception { + runTest("compiler/testData/codegen/box/enum/kt7257_fullyQualifiedReceiver.kt"); + } + + @Test + @TestMetadata("kt7257_namedLocalFun.kt") + public void testKt7257_namedLocalFun() throws Exception { + runTest("compiler/testData/codegen/box/enum/kt7257_namedLocalFun.kt"); + } + + @Test + @TestMetadata("kt7257_notInline.kt") + public void testKt7257_notInline() throws Exception { + runTest("compiler/testData/codegen/box/enum/kt7257_notInline.kt"); + } + + @Test + @TestMetadata("kt9711.kt") + public void testKt9711() throws Exception { + runTest("compiler/testData/codegen/box/enum/kt9711.kt"); + } + + @Test + @TestMetadata("kt9711_2.kt") + public void testKt9711_2() throws Exception { + runTest("compiler/testData/codegen/box/enum/kt9711_2.kt"); + } + + @Test + @TestMetadata("manyDefaultParameters.kt") + public void testManyDefaultParameters() throws Exception { + runTest("compiler/testData/codegen/box/enum/manyDefaultParameters.kt"); + } + + @Test + @TestMetadata("ordinal.kt") + public void testOrdinal() throws Exception { + runTest("compiler/testData/codegen/box/enum/ordinal.kt"); + } + + @Test + @TestMetadata("ordinalsWithEnumEntitiesOverrides.kt") + public void testOrdinalsWithEnumEntitiesOverrides() throws Exception { + runTest("compiler/testData/codegen/box/enum/ordinalsWithEnumEntitiesOverrides.kt"); + } + + @Test + @TestMetadata("overloadedEnumValues.kt") + public void testOverloadedEnumValues() throws Exception { + runTest("compiler/testData/codegen/box/enum/overloadedEnumValues.kt"); + } + + @Test + @TestMetadata("refToThis.kt") + public void testRefToThis() throws Exception { + runTest("compiler/testData/codegen/box/enum/refToThis.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/enum/simple.kt"); + } + + @Test + @TestMetadata("sortEnumEntries.kt") + public void testSortEnumEntries() throws Exception { + runTest("compiler/testData/codegen/box/enum/sortEnumEntries.kt"); + } + + @Test + @TestMetadata("superCallInEnumLiteral.kt") + public void testSuperCallInEnumLiteral() throws Exception { + runTest("compiler/testData/codegen/box/enum/superCallInEnumLiteral.kt"); + } + + @Test + @TestMetadata("toString.kt") + public void testToString() throws Exception { + runTest("compiler/testData/codegen/box/enum/toString.kt"); + } + + @Test + @TestMetadata("valueof.kt") + public void testValueof() throws Exception { + runTest("compiler/testData/codegen/box/enum/valueof.kt"); + } + + @Test + @TestMetadata("whenInObject.kt") + public void testWhenInObject() throws Exception { + runTest("compiler/testData/codegen/box/enum/whenInObject.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/enum/defaultCtor") + @TestDataPath("$PROJECT_ROOT") + public class DefaultCtor { + @Test + public void testAllFilesPresentInDefaultCtor() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/enum/defaultCtor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("constructorWithDefaultArguments.kt") + public void testConstructorWithDefaultArguments() throws Exception { + runTest("compiler/testData/codegen/box/enum/defaultCtor/constructorWithDefaultArguments.kt"); + } + + @Test + @TestMetadata("constructorWithVararg.kt") + public void testConstructorWithVararg() throws Exception { + runTest("compiler/testData/codegen/box/enum/defaultCtor/constructorWithVararg.kt"); + } + + @Test + @TestMetadata("entryClassConstructorWithDefaultArguments.kt") + public void testEntryClassConstructorWithDefaultArguments() throws Exception { + runTest("compiler/testData/codegen/box/enum/defaultCtor/entryClassConstructorWithDefaultArguments.kt"); + } + + @Test + @TestMetadata("entryClassConstructorWithVarargs.kt") + public void testEntryClassConstructorWithVarargs() throws Exception { + runTest("compiler/testData/codegen/box/enum/defaultCtor/entryClassConstructorWithVarargs.kt"); + } + + @Test + @TestMetadata("noPrimaryConstructor.kt") + public void testNoPrimaryConstructor() throws Exception { + runTest("compiler/testData/codegen/box/enum/defaultCtor/noPrimaryConstructor.kt"); + } + + @Test + @TestMetadata("secondaryConstructorWithDefaultArguments.kt") + public void testSecondaryConstructorWithDefaultArguments() throws Exception { + runTest("compiler/testData/codegen/box/enum/defaultCtor/secondaryConstructorWithDefaultArguments.kt"); + } + + @Test + @TestMetadata("secondaryConstructorWithVararg.kt") + public void testSecondaryConstructorWithVararg() throws Exception { + runTest("compiler/testData/codegen/box/enum/defaultCtor/secondaryConstructorWithVararg.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/evaluate") + @TestDataPath("$PROJECT_ROOT") + public class Evaluate { + @Test + public void testAllFilesPresentInEvaluate() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/evaluate"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt9443.kt") + public void testKt9443() throws Exception { + runTest("compiler/testData/codegen/box/evaluate/kt9443.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/exclExcl") + @TestDataPath("$PROJECT_ROOT") + public class ExclExcl { + @Test + public void testAllFilesPresentInExclExcl() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/exclExcl"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("genericNull.kt") + public void testGenericNull() throws Exception { + runTest("compiler/testData/codegen/box/exclExcl/genericNull.kt"); + } + + @Test + @TestMetadata("kt48440.kt") + public void testKt48440() throws Exception { + runTest("compiler/testData/codegen/box/exclExcl/kt48440.kt"); + } + + @Test + @TestMetadata("kt48440_2.kt") + public void testKt48440_2() throws Exception { + runTest("compiler/testData/codegen/box/exclExcl/kt48440_2.kt"); + } + + @Test + @TestMetadata("primitive.kt") + public void testPrimitive() throws Exception { + runTest("compiler/testData/codegen/box/exclExcl/primitive.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/extensionClasses") + @TestDataPath("$PROJECT_ROOT") + public class ExtensionClasses { + @Test + public void testAllFilesPresentInExtensionClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/extensionFunctions") + @TestDataPath("$PROJECT_ROOT") + public class ExtensionFunctions { + @Test + public void testAllFilesPresentInExtensionFunctions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionFunctions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("classMethodCallExtensionSuper.kt") + public void testClassMethodCallExtensionSuper() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/classMethodCallExtensionSuper.kt"); + } + + @Test + @TestMetadata("defaultMethodInterfaceCallExtensionSuper.kt") + public void testDefaultMethodInterfaceCallExtensionSuper() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/defaultMethodInterfaceCallExtensionSuper.kt"); + } + + @Test + @TestMetadata("executionOrder.kt") + public void testExecutionOrder() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/executionOrder.kt"); + } + + @Test + @TestMetadata("extensionFunctionAsSupertype.kt") + public void testExtensionFunctionAsSupertype() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/extensionFunctionAsSupertype.kt"); + } + + @Test + @TestMetadata("kt1061.kt") + public void testKt1061() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/kt1061.kt"); + } + + @Test + @TestMetadata("kt1249.kt") + public void testKt1249() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/kt1249.kt"); + } + + @Test + @TestMetadata("kt1290.kt") + public void testKt1290() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/kt1290.kt"); + } + + @Test + @TestMetadata("kt13312.kt") + public void testKt13312() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/kt13312.kt"); + } + + @Test + @TestMetadata("kt1776.kt") + public void testKt1776() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/kt1776.kt"); + } + + @Test + @TestMetadata("kt1953.kt") + public void testKt1953() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/kt1953.kt"); + } + + @Test + @TestMetadata("kt1953_class.kt") + public void testKt1953_class() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/kt1953_class.kt"); + } + + @Test + @TestMetadata("kt23675.kt") + public void testKt23675() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/kt23675.kt"); + } + + @Test + @TestMetadata("kt3285.kt") + public void testKt3285() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/kt3285.kt"); + } + + @Test + @TestMetadata("kt3298.kt") + public void testKt3298() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/kt3298.kt"); + } + + @Test + @TestMetadata("kt3646.kt") + public void testKt3646() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/kt3646.kt"); + } + + @Test + @TestMetadata("kt3969.kt") + public void testKt3969() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/kt3969.kt"); + } + + @Test + @TestMetadata("kt4228.kt") + public void testKt4228() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/kt4228.kt"); + } + + @Test + @TestMetadata("kt475.kt") + public void testKt475() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/kt475.kt"); + } + + @Test + @TestMetadata("kt5467.kt") + public void testKt5467() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/kt5467.kt"); + } + + @Test + @TestMetadata("kt606.kt") + public void testKt606() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/kt606.kt"); + } + + @Test + @TestMetadata("kt865.kt") + public void testKt865() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/kt865.kt"); + } + + @Test + @TestMetadata("memberExtensionEqualsHashCodeToStringInInterface.kt") + public void testMemberExtensionEqualsHashCodeToStringInInterface() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/memberExtensionEqualsHashCodeToStringInInterface.kt"); + } + + @Test + @TestMetadata("nested2.kt") + public void testNested2() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/nested2.kt"); + } + + @Test + @TestMetadata("shared.kt") + public void testShared() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/shared.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/simple.kt"); + } + + @Test + @TestMetadata("thisMethodInObjectLiteral.kt") + public void testThisMethodInObjectLiteral() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/thisMethodInObjectLiteral.kt"); + } + + @Test + @TestMetadata("virtual.kt") + public void testVirtual() throws Exception { + runTest("compiler/testData/codegen/box/extensionFunctions/virtual.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/extensionFunctions/contextReceivers") + @TestDataPath("$PROJECT_ROOT") + public class ContextReceivers { + @Test + public void testAllFilesPresentInContextReceivers() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionFunctions/contextReceivers"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/extensionFunctions/contextReceivers/fromKEEP") + @TestDataPath("$PROJECT_ROOT") + public class FromKEEP { + @Test + public void testAllFilesPresentInFromKEEP() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionFunctions/contextReceivers/fromKEEP"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/extensionProperties") + @TestDataPath("$PROJECT_ROOT") + public class ExtensionProperties { + @Test + @TestMetadata("accessorForPrivateSetter.kt") + public void testAccessorForPrivateSetter() throws Exception { + runTest("compiler/testData/codegen/box/extensionProperties/accessorForPrivateSetter.kt"); + } + + @Test + public void testAllFilesPresentInExtensionProperties() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/extensionProperties"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("genericValForPrimitiveType.kt") + public void testGenericValForPrimitiveType() throws Exception { + runTest("compiler/testData/codegen/box/extensionProperties/genericValForPrimitiveType.kt"); + } + + @Test + @TestMetadata("genericVarForPrimitiveType.kt") + public void testGenericVarForPrimitiveType() throws Exception { + runTest("compiler/testData/codegen/box/extensionProperties/genericVarForPrimitiveType.kt"); + } + + @Test + @TestMetadata("inClass.kt") + public void testInClass() throws Exception { + runTest("compiler/testData/codegen/box/extensionProperties/inClass.kt"); + } + + @Test + @TestMetadata("inClassLongTypeInReceiver.kt") + public void testInClassLongTypeInReceiver() throws Exception { + runTest("compiler/testData/codegen/box/extensionProperties/inClassLongTypeInReceiver.kt"); + } + + @Test + @TestMetadata("inClassWithGetter.kt") + public void testInClassWithGetter() throws Exception { + runTest("compiler/testData/codegen/box/extensionProperties/inClassWithGetter.kt"); + } + + @Test + @TestMetadata("inClassWithPrivateGetter.kt") + public void testInClassWithPrivateGetter() throws Exception { + runTest("compiler/testData/codegen/box/extensionProperties/inClassWithPrivateGetter.kt"); + } + + @Test + @TestMetadata("inClassWithPrivateSetter.kt") + public void testInClassWithPrivateSetter() throws Exception { + runTest("compiler/testData/codegen/box/extensionProperties/inClassWithPrivateSetter.kt"); + } + + @Test + @TestMetadata("inClassWithSetter.kt") + public void testInClassWithSetter() throws Exception { + runTest("compiler/testData/codegen/box/extensionProperties/inClassWithSetter.kt"); + } + + @Test + @TestMetadata("kt46952.kt") + public void testKt46952() throws Exception { + runTest("compiler/testData/codegen/box/extensionProperties/kt46952.kt"); + } + + @Test + @TestMetadata("kt9897.kt") + public void testKt9897() throws Exception { + runTest("compiler/testData/codegen/box/extensionProperties/kt9897.kt"); + } + + @Test + @TestMetadata("kt9897_topLevel.kt") + public void testKt9897_topLevel() throws Exception { + runTest("compiler/testData/codegen/box/extensionProperties/kt9897_topLevel.kt"); + } + + @Test + @TestMetadata("nonAbstractInInterface.kt") + public void testNonAbstractInInterface() throws Exception { + runTest("compiler/testData/codegen/box/extensionProperties/nonAbstractInInterface.kt"); + } + + @Test + @TestMetadata("topLevel.kt") + public void testTopLevel() throws Exception { + runTest("compiler/testData/codegen/box/extensionProperties/topLevel.kt"); + } + + @Test + @TestMetadata("topLevelLongTypeInReceiver.kt") + public void testTopLevelLongTypeInReceiver() throws Exception { + runTest("compiler/testData/codegen/box/extensionProperties/topLevelLongTypeInReceiver.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/external") + @TestDataPath("$PROJECT_ROOT") + public class External { + @Test + public void testAllFilesPresentInExternal() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/external"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/fakeOverride") + @TestDataPath("$PROJECT_ROOT") + public class FakeOverride { + @Test + public void testAllFilesPresentInFakeOverride() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fakeOverride"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("diamondFunction.kt") + public void testDiamondFunction() throws Exception { + runTest("compiler/testData/codegen/box/fakeOverride/diamondFunction.kt"); + } + + @Test + @TestMetadata("function.kt") + public void testFunction() throws Exception { + runTest("compiler/testData/codegen/box/fakeOverride/function.kt"); + } + + @Test + @TestMetadata("internalFromFriendModule.kt") + public void testInternalFromFriendModule() throws Exception { + runTest("compiler/testData/codegen/box/fakeOverride/internalFromFriendModule.kt"); + } + + @Test + @TestMetadata("kt49371.kt") + public void testKt49371() throws Exception { + runTest("compiler/testData/codegen/box/fakeOverride/kt49371.kt"); + } + + @Test + @TestMetadata("privateFakeOverrides0.kt") + public void testPrivateFakeOverrides0() throws Exception { + runTest("compiler/testData/codegen/box/fakeOverride/privateFakeOverrides0.kt"); + } + + @Test + @TestMetadata("privateFakeOverrides1.kt") + public void testPrivateFakeOverrides1() throws Exception { + runTest("compiler/testData/codegen/box/fakeOverride/privateFakeOverrides1.kt"); + } + + @Test + @TestMetadata("propertyGetter.kt") + public void testPropertyGetter() throws Exception { + runTest("compiler/testData/codegen/box/fakeOverride/propertyGetter.kt"); + } + + @Test + @TestMetadata("propertySetter.kt") + public void testPropertySetter() throws Exception { + runTest("compiler/testData/codegen/box/fakeOverride/propertySetter.kt"); + } + + @Test + @TestMetadata("varianceOverload.kt") + public void testVarianceOverload() throws Exception { + runTest("compiler/testData/codegen/box/fakeOverride/varianceOverload.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/fieldRename") + @TestDataPath("$PROJECT_ROOT") + public class FieldRename { + @Test + public void testAllFilesPresentInFieldRename() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fieldRename"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("constructorAndClassObject.kt") + public void testConstructorAndClassObject() throws Exception { + runTest("compiler/testData/codegen/box/fieldRename/constructorAndClassObject.kt"); + } + + @Test + @TestMetadata("delegates.kt") + public void testDelegates() throws Exception { + runTest("compiler/testData/codegen/box/fieldRename/delegates.kt"); + } + + @Test + @TestMetadata("genericPropertyWithItself.kt") + public void testGenericPropertyWithItself() throws Exception { + runTest("compiler/testData/codegen/box/fieldRename/genericPropertyWithItself.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/finally") + @TestDataPath("$PROJECT_ROOT") + public class Finally { + @Test + public void testAllFilesPresentInFinally() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/finally"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("breakAndOuterFinally.kt") + public void testBreakAndOuterFinally() throws Exception { + runTest("compiler/testData/codegen/box/finally/breakAndOuterFinally.kt"); + } + + @Test + @TestMetadata("continueAndOuterFinally.kt") + public void testContinueAndOuterFinally() throws Exception { + runTest("compiler/testData/codegen/box/finally/continueAndOuterFinally.kt"); + } + + @Test + @TestMetadata("finallyAndFinally.kt") + public void testFinallyAndFinally() throws Exception { + runTest("compiler/testData/codegen/box/finally/finallyAndFinally.kt"); + } + + @Test + @TestMetadata("kt31923_break.kt") + public void testKt31923_break() throws Exception { + runTest("compiler/testData/codegen/box/finally/kt31923_break.kt"); + } + + @Test + @TestMetadata("kt31923_continue.kt") + public void testKt31923_continue() throws Exception { + runTest("compiler/testData/codegen/box/finally/kt31923_continue.kt"); + } + + @Test + @TestMetadata("kt31923_return.kt") + public void testKt31923_return() throws Exception { + runTest("compiler/testData/codegen/box/finally/kt31923_return.kt"); + } + + @Test + @TestMetadata("kt3549.kt") + public void testKt3549() throws Exception { + runTest("compiler/testData/codegen/box/finally/kt3549.kt"); + } + + @Test + @TestMetadata("kt3706.kt") + public void testKt3706() throws Exception { + runTest("compiler/testData/codegen/box/finally/kt3706.kt"); + } + + @Test + @TestMetadata("kt3867.kt") + public void testKt3867() throws Exception { + runTest("compiler/testData/codegen/box/finally/kt3867.kt"); + } + + @Test + @TestMetadata("kt3874.kt") + public void testKt3874() throws Exception { + runTest("compiler/testData/codegen/box/finally/kt3874.kt"); + } + + @Test + @TestMetadata("kt3894.kt") + public void testKt3894() throws Exception { + runTest("compiler/testData/codegen/box/finally/kt3894.kt"); + } + + @Test + @TestMetadata("kt4134.kt") + public void testKt4134() throws Exception { + runTest("compiler/testData/codegen/box/finally/kt4134.kt"); + } + + @Test + @TestMetadata("loopAndFinally.kt") + public void testLoopAndFinally() throws Exception { + runTest("compiler/testData/codegen/box/finally/loopAndFinally.kt"); + } + + @Test + @TestMetadata("nestedFinallyAndNonFinallyTry.kt") + public void testNestedFinallyAndNonFinallyTry() throws Exception { + runTest("compiler/testData/codegen/box/finally/nestedFinallyAndNonFinallyTry.kt"); + } + + @Test + @TestMetadata("nestedFinallyAndNonFinallyTry2.kt") + public void testNestedFinallyAndNonFinallyTry2() throws Exception { + runTest("compiler/testData/codegen/box/finally/nestedFinallyAndNonFinallyTry2.kt"); + } + + @Test + @TestMetadata("nestedFinallyAndNonFinallyTry3.kt") + public void testNestedFinallyAndNonFinallyTry3() throws Exception { + runTest("compiler/testData/codegen/box/finally/nestedFinallyAndNonFinallyTry3.kt"); + } + + @Test + @TestMetadata("nestedFinallyAndNonFinallyTry4.kt") + public void testNestedFinallyAndNonFinallyTry4() throws Exception { + runTest("compiler/testData/codegen/box/finally/nestedFinallyAndNonFinallyTry4.kt"); + } + + @Test + @TestMetadata("notChainCatch.kt") + public void testNotChainCatch() throws Exception { + runTest("compiler/testData/codegen/box/finally/notChainCatch.kt"); + } + + @Test + @TestMetadata("objectInFinally.kt") + public void testObjectInFinally() throws Exception { + runTest("compiler/testData/codegen/box/finally/objectInFinally.kt"); + } + + @Test + @TestMetadata("returnNullFromInlined.kt") + public void testReturnNullFromInlined() throws Exception { + runTest("compiler/testData/codegen/box/finally/returnNullFromInlined.kt"); + } + + @Test + @TestMetadata("someStuff.kt") + public void testSomeStuff() throws Exception { + runTest("compiler/testData/codegen/box/finally/someStuff.kt"); + } + + @Test + @TestMetadata("tryFinally.kt") + public void testTryFinally() throws Exception { + runTest("compiler/testData/codegen/box/finally/tryFinally.kt"); + } + + @Test + @TestMetadata("tryLoopTry.kt") + public void testTryLoopTry() throws Exception { + runTest("compiler/testData/codegen/box/finally/tryLoopTry.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/fir") + @TestDataPath("$PROJECT_ROOT") + public class Fir { + @Test + public void testAllFilesPresentInFir() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fir"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("anonymousOverrideWithDefaultInLocalOverridden.kt") + public void testAnonymousOverrideWithDefaultInLocalOverridden() throws Exception { + runTest("compiler/testData/codegen/box/fir/anonymousOverrideWithDefaultInLocalOverridden.kt"); + } + + @Test + @TestMetadata("anonymousOverrideWithDefaultInOverridden.kt") + public void testAnonymousOverrideWithDefaultInOverridden() throws Exception { + runTest("compiler/testData/codegen/box/fir/anonymousOverrideWithDefaultInOverridden.kt"); + } + + @Test + @TestMetadata("classCanNotBeCastedToVoid.kt") + public void testClassCanNotBeCastedToVoid() throws Exception { + runTest("compiler/testData/codegen/box/fir/classCanNotBeCastedToVoid.kt"); + } + + @Test + @TestMetadata("deserializedOptInDeprecated.kt") + public void testDeserializedOptInDeprecated() throws Exception { + runTest("compiler/testData/codegen/box/fir/deserializedOptInDeprecated.kt"); + } + + @Test + @TestMetadata("falsePositiveBoundSmartcast.kt") + public void testFalsePositiveBoundSmartcast() throws Exception { + runTest("compiler/testData/codegen/box/fir/falsePositiveBoundSmartcast.kt"); + } + + @Test + @TestMetadata("localOverrideWithDefaultInLocalOverridden.kt") + public void testLocalOverrideWithDefaultInLocalOverridden() throws Exception { + runTest("compiler/testData/codegen/box/fir/localOverrideWithDefaultInLocalOverridden.kt"); + } + + @Test + @TestMetadata("localOverrideWithDefaultInOverridden.kt") + public void testLocalOverrideWithDefaultInOverridden() throws Exception { + runTest("compiler/testData/codegen/box/fir/localOverrideWithDefaultInOverridden.kt"); + } + + @Test + @TestMetadata("nestedClassTypeParameterDeserialization.kt") + public void testNestedClassTypeParameterDeserialization() throws Exception { + runTest("compiler/testData/codegen/box/fir/nestedClassTypeParameterDeserialization.kt"); + } + + @Test + @TestMetadata("SamWithReceiverMavenProjectImportHandler.kt") + public void testSamWithReceiverMavenProjectImportHandler() throws Exception { + runTest("compiler/testData/codegen/box/fir/SamWithReceiverMavenProjectImportHandler.kt"); + } + + @Test + @TestMetadata("toLong.kt") + public void testToLong() throws Exception { + runTest("compiler/testData/codegen/box/fir/toLong.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/fullJdk") + @TestDataPath("$PROJECT_ROOT") + public class FullJdk { + @Test + public void testAllFilesPresentInFullJdk() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/fullJdk/native") + @TestDataPath("$PROJECT_ROOT") + public class Native { + @Test + public void testAllFilesPresentInNative() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/native"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/fullJdk/regressions") + @TestDataPath("$PROJECT_ROOT") + public class Regressions { + @Test + public void testAllFilesPresentInRegressions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/fullJdk/regressions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/funInterface") + @TestDataPath("$PROJECT_ROOT") + public class FunInterface { + @Test + public void testAllFilesPresentInFunInterface() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("basicFunInterface.kt") + public void testBasicFunInterface() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/basicFunInterface.kt"); + } + + @Test + @TestMetadata("basicFunInterfaceConversion.kt") + public void testBasicFunInterfaceConversion() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/basicFunInterfaceConversion.kt"); + } + + @Test + @TestMetadata("basicFunInterfaceConversionClash.kt") + public void testBasicFunInterfaceConversionClash() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/basicFunInterfaceConversionClash.kt"); + } + + @Test + @TestMetadata("castFromAny.kt") + public void testCastFromAny() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/castFromAny.kt"); + } + + @Test + @TestMetadata("contravariantIntersectionType.kt") + public void testContravariantIntersectionType() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/contravariantIntersectionType.kt"); + } + + @Test + @TestMetadata("contravariantIntersectionTypeWithNonTrivialCommonSupertype.kt") + public void testContravariantIntersectionTypeWithNonTrivialCommonSupertype() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/contravariantIntersectionTypeWithNonTrivialCommonSupertype.kt"); + } + + @Test + @TestMetadata("contravariantIntersectionTypeWithNonTrivialCommonSupertype2.kt") + public void testContravariantIntersectionTypeWithNonTrivialCommonSupertype2() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/contravariantIntersectionTypeWithNonTrivialCommonSupertype2.kt"); + } + + @Test + @TestMetadata("funConversionInVararg.kt") + public void testFunConversionInVararg() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/funConversionInVararg.kt"); + } + + @Test + @TestMetadata("funInterfaceCallInLambda.kt") + public void testFunInterfaceCallInLambda() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/funInterfaceCallInLambda.kt"); + } + + @Test + @TestMetadata("funInterfaceInheritance.kt") + public void testFunInterfaceInheritance() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/funInterfaceInheritance.kt"); + } + + @Test + @TestMetadata("funInterfaceTypealias.kt") + public void testFunInterfaceTypealias() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/funInterfaceTypealias.kt"); + } + + @Test + @TestMetadata("funInterfaceWithReceiver.kt") + public void testFunInterfaceWithReceiver() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/funInterfaceWithReceiver.kt"); + } + + @Test + @TestMetadata("inlinedSamWrapper.kt") + public void testInlinedSamWrapper() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/inlinedSamWrapper.kt"); + } + + @Test + @TestMetadata("intersectionTypeToFunInterfaceConversion.kt") + public void testIntersectionTypeToFunInterfaceConversion() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/intersectionTypeToFunInterfaceConversion.kt"); + } + + @Test + @TestMetadata("irrelevantPrivateDeclarations.kt") + public void testIrrelevantPrivateDeclarations() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/irrelevantPrivateDeclarations.kt"); + } + + @Test + @TestMetadata("kt41670.kt") + public void testKt41670() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/kt41670.kt"); + } + + @Test + @TestMetadata("kt45444_privateFunInterface.kt") + public void testKt45444_privateFunInterface() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/kt45444_privateFunInterface.kt"); + } + + @Test + @TestMetadata("kt46512_indyFunInterfaceOverCallableReference.kt") + public void testKt46512_indyFunInterfaceOverCallableReference() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/kt46512_indyFunInterfaceOverCallableReference.kt"); + } + + @Test + @TestMetadata("kt46908_functionSupertype.kt") + public void testKt46908_functionSupertype() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/kt46908_functionSupertype.kt"); + } + + @Test + @TestMetadata("multimodule.kt") + public void testMultimodule() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/multimodule.kt"); + } + + @Test + @TestMetadata("noOptimizedCallableReferences.kt") + public void testNoOptimizedCallableReferences() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/noOptimizedCallableReferences.kt"); + } + + @Test + @TestMetadata("nonAbstractMethod.kt") + public void testNonAbstractMethod() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/nonAbstractMethod.kt"); + } + + @Test + @TestMetadata("nullableSam.kt") + public void testNullableSam() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/nullableSam.kt"); + } + + @Test + @TestMetadata("partialSam.kt") + public void testPartialSam() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/partialSam.kt"); + } + + @Test + @TestMetadata("primitiveConversions.kt") + public void testPrimitiveConversions() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/primitiveConversions.kt"); + } + + @Test + @TestMetadata("receiverEvaluatedOnce.kt") + public void testReceiverEvaluatedOnce() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/receiverEvaluatedOnce.kt"); + } + + @Test + @TestMetadata("samConstructorExplicitInvocation.kt") + public void testSamConstructorExplicitInvocation() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/samConstructorExplicitInvocation.kt"); + } + + @Test + @TestMetadata("samConversionToGenericInterfaceInGenericFun.kt") + public void testSamConversionToGenericInterfaceInGenericFun() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/samConversionToGenericInterfaceInGenericFun.kt"); + } + + @Test + @TestMetadata("subtypeOfFunctionalTypeToFunInterfaceConversion.kt") + public void testSubtypeOfFunctionalTypeToFunInterfaceConversion() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/subtypeOfFunctionalTypeToFunInterfaceConversion.kt"); + } + + @Test + @TestMetadata("suspendFunInterfaceConversionCodegen.kt") + public void testSuspendFunInterfaceConversionCodegen() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/suspendFunInterfaceConversionCodegen.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/funInterface/equality") + @TestDataPath("$PROJECT_ROOT") + public class Equality { + @Test + public void testAllFilesPresentInEquality() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/funInterface/equality"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("functionReferencesBound.kt") + public void testFunctionReferencesBound() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/equality/functionReferencesBound.kt"); + } + + @Test + @TestMetadata("functionReferencesUnbound.kt") + public void testFunctionReferencesUnbound() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/equality/functionReferencesUnbound.kt"); + } + + @Test + @TestMetadata("lambdaRuntimeConversion.kt") + public void testLambdaRuntimeConversion() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/equality/lambdaRuntimeConversion.kt"); + } + + @Test + @TestMetadata("localFunctionReferences.kt") + public void testLocalFunctionReferences() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/equality/localFunctionReferences.kt"); + } + + @Test + @TestMetadata("simpleLambdas.kt") + public void testSimpleLambdas() throws Exception { + runTest("compiler/testData/codegen/box/funInterface/equality/simpleLambdas.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/functions") + @TestDataPath("$PROJECT_ROOT") + public class Functions { + @Test + public void testAllFilesPresentInFunctions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("coerceVoidToArray.kt") + public void testCoerceVoidToArray() throws Exception { + runTest("compiler/testData/codegen/box/functions/coerceVoidToArray.kt"); + } + + @Test + @TestMetadata("coerceVoidToObject.kt") + public void testCoerceVoidToObject() throws Exception { + runTest("compiler/testData/codegen/box/functions/coerceVoidToObject.kt"); + } + + @Test + @TestMetadata("defaultargs.kt") + public void testDefaultargs() throws Exception { + runTest("compiler/testData/codegen/box/functions/defaultargs.kt"); + } + + @Test + @TestMetadata("defaultargs1.kt") + public void testDefaultargs1() throws Exception { + runTest("compiler/testData/codegen/box/functions/defaultargs1.kt"); + } + + @Test + @TestMetadata("defaultargs2.kt") + public void testDefaultargs2() throws Exception { + runTest("compiler/testData/codegen/box/functions/defaultargs2.kt"); + } + + @Test + @TestMetadata("defaultargs3.kt") + public void testDefaultargs3() throws Exception { + runTest("compiler/testData/codegen/box/functions/defaultargs3.kt"); + } + + @Test + @TestMetadata("defaultargs4.kt") + public void testDefaultargs4() throws Exception { + runTest("compiler/testData/codegen/box/functions/defaultargs4.kt"); + } + + @Test + @TestMetadata("defaultargs5.kt") + public void testDefaultargs5() throws Exception { + runTest("compiler/testData/codegen/box/functions/defaultargs5.kt"); + } + + @Test + @TestMetadata("defaultargs6.kt") + public void testDefaultargs6() throws Exception { + runTest("compiler/testData/codegen/box/functions/defaultargs6.kt"); + } + + @Test + @TestMetadata("defaultargs7.kt") + public void testDefaultargs7() throws Exception { + runTest("compiler/testData/codegen/box/functions/defaultargs7.kt"); + } + + @Test + @TestMetadata("delegatedPropertyWithMultipleOverriddens_generics.kt") + public void testDelegatedPropertyWithMultipleOverriddens_generics() throws Exception { + runTest("compiler/testData/codegen/box/functions/delegatedPropertyWithMultipleOverriddens_generics.kt"); + } + + @Test + @TestMetadata("delegatedPropertyWithMultipleOverriddens_noGenerics.kt") + public void testDelegatedPropertyWithMultipleOverriddens_noGenerics() throws Exception { + runTest("compiler/testData/codegen/box/functions/delegatedPropertyWithMultipleOverriddens_noGenerics.kt"); + } + + @Test + @TestMetadata("ea33909.kt") + public void testEa33909() throws Exception { + runTest("compiler/testData/codegen/box/functions/ea33909.kt"); + } + + @Test + @TestMetadata("fakeDescriptorWithSeveralOverridenOne.kt") + public void testFakeDescriptorWithSeveralOverridenOne() throws Exception { + runTest("compiler/testData/codegen/box/functions/fakeDescriptorWithSeveralOverridenOne.kt"); + } + + @Test + @TestMetadata("infixRecursiveCall.kt") + public void testInfixRecursiveCall() throws Exception { + runTest("compiler/testData/codegen/box/functions/infixRecursiveCall.kt"); + } + + @Test + @TestMetadata("kt1038.kt") + public void testKt1038() throws Exception { + runTest("compiler/testData/codegen/box/functions/kt1038.kt"); + } + + @Test + @TestMetadata("kt1199.kt") + public void testKt1199() throws Exception { + runTest("compiler/testData/codegen/box/functions/kt1199.kt"); + } + + @Test + @TestMetadata("kt1413.kt") + public void testKt1413() throws Exception { + runTest("compiler/testData/codegen/box/functions/kt1413.kt"); + } + + @Test + @TestMetadata("kt1649_1.kt") + public void testKt1649_1() throws Exception { + runTest("compiler/testData/codegen/box/functions/kt1649_1.kt"); + } + + @Test + @TestMetadata("kt1649_2.kt") + public void testKt1649_2() throws Exception { + runTest("compiler/testData/codegen/box/functions/kt1649_2.kt"); + } + + @Test + @TestMetadata("kt2270.kt") + public void testKt2270() throws Exception { + runTest("compiler/testData/codegen/box/functions/kt2270.kt"); + } + + @Test + @TestMetadata("kt2271.kt") + public void testKt2271() throws Exception { + runTest("compiler/testData/codegen/box/functions/kt2271.kt"); + } + + @Test + @TestMetadata("kt2280.kt") + public void testKt2280() throws Exception { + runTest("compiler/testData/codegen/box/functions/kt2280.kt"); + } + + @Test + @TestMetadata("kt2481.kt") + public void testKt2481() throws Exception { + runTest("compiler/testData/codegen/box/functions/kt2481.kt"); + } + + @Test + @TestMetadata("kt2716.kt") + public void testKt2716() throws Exception { + runTest("compiler/testData/codegen/box/functions/kt2716.kt"); + } + + @Test + @TestMetadata("kt2739.kt") + public void testKt2739() throws Exception { + runTest("compiler/testData/codegen/box/functions/kt2739.kt"); + } + + @Test + @TestMetadata("kt2929.kt") + public void testKt2929() throws Exception { + runTest("compiler/testData/codegen/box/functions/kt2929.kt"); + } + + @Test + @TestMetadata("kt3214.kt") + public void testKt3214() throws Exception { + runTest("compiler/testData/codegen/box/functions/kt3214.kt"); + } + + @Test + @TestMetadata("kt3313.kt") + public void testKt3313() throws Exception { + runTest("compiler/testData/codegen/box/functions/kt3313.kt"); + } + + @Test + @TestMetadata("kt3573.kt") + public void testKt3573() throws Exception { + runTest("compiler/testData/codegen/box/functions/kt3573.kt"); + } + + @Test + @TestMetadata("kt3724.kt") + public void testKt3724() throws Exception { + runTest("compiler/testData/codegen/box/functions/kt3724.kt"); + } + + @Test + @TestMetadata("kt395.kt") + public void testKt395() throws Exception { + runTest("compiler/testData/codegen/box/functions/kt395.kt"); + } + + @Test + @TestMetadata("kt47449.kt") + public void testKt47449() throws Exception { + runTest("compiler/testData/codegen/box/functions/kt47449.kt"); + } + + @Test + @TestMetadata("kt47527.kt") + public void testKt47527() throws Exception { + runTest("compiler/testData/codegen/box/functions/kt47527.kt"); + } + + @Test + @TestMetadata("kt48058.kt") + public void testKt48058() throws Exception { + runTest("compiler/testData/codegen/box/functions/kt48058.kt"); + } + + @Test + @TestMetadata("kt785.kt") + public void testKt785() throws Exception { + runTest("compiler/testData/codegen/box/functions/kt785.kt"); + } + + @Test + @TestMetadata("kt873.kt") + public void testKt873() throws Exception { + runTest("compiler/testData/codegen/box/functions/kt873.kt"); + } + + @Test + @TestMetadata("localFunction.kt") + public void testLocalFunction() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunction.kt"); + } + + @Test + @TestMetadata("localReturnInsideFunctionExpression.kt") + public void testLocalReturnInsideFunctionExpression() throws Exception { + runTest("compiler/testData/codegen/box/functions/localReturnInsideFunctionExpression.kt"); + } + + @Test + @TestMetadata("mutualInline.kt") + public void testMutualInline() throws Exception { + runTest("compiler/testData/codegen/box/functions/mutualInline.kt"); + } + + @Test + @TestMetadata("nothisnoclosure.kt") + public void testNothisnoclosure() throws Exception { + runTest("compiler/testData/codegen/box/functions/nothisnoclosure.kt"); + } + + @Test + @TestMetadata("overloadByInterfaceType.kt") + public void testOverloadByInterfaceType() throws Exception { + runTest("compiler/testData/codegen/box/functions/overloadByInterfaceType.kt"); + } + + @Test + @TestMetadata("prefixRecursiveCall.kt") + public void testPrefixRecursiveCall() throws Exception { + runTest("compiler/testData/codegen/box/functions/prefixRecursiveCall.kt"); + } + + @Test + @TestMetadata("recursiveCompareTo.kt") + public void testRecursiveCompareTo() throws Exception { + runTest("compiler/testData/codegen/box/functions/recursiveCompareTo.kt"); + } + + @Test + @TestMetadata("recursiveIncrementCall.kt") + public void testRecursiveIncrementCall() throws Exception { + runTest("compiler/testData/codegen/box/functions/recursiveIncrementCall.kt"); + } + + @Test + @TestMetadata("typeParameterAsUpperBound.kt") + public void testTypeParameterAsUpperBound() throws Exception { + runTest("compiler/testData/codegen/box/functions/typeParameterAsUpperBound.kt"); + } + + @Test + @TestMetadata("typeParametersInLocalFunction.kt") + public void testTypeParametersInLocalFunction() throws Exception { + runTest("compiler/testData/codegen/box/functions/typeParametersInLocalFunction.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/functions/bigArity") + @TestDataPath("$PROJECT_ROOT") + public class BigArity { + @Test + public void testAllFilesPresentInBigArity() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/bigArity"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("function255.kt") + public void testFunction255() throws Exception { + runTest("compiler/testData/codegen/box/functions/bigArity/function255.kt"); + } + + @Test + @TestMetadata("instanceOfCallableReference.kt") + public void testInstanceOfCallableReference() throws Exception { + runTest("compiler/testData/codegen/box/functions/bigArity/instanceOfCallableReference.kt"); + } + + @Test + @TestMetadata("invokeCallableReference.kt") + public void testInvokeCallableReference() throws Exception { + runTest("compiler/testData/codegen/box/functions/bigArity/invokeCallableReference.kt"); + } + + @Test + @TestMetadata("invokeLambda.kt") + public void testInvokeLambda() throws Exception { + runTest("compiler/testData/codegen/box/functions/bigArity/invokeLambda.kt"); + } + + @Test + @TestMetadata("invokeMemberCallableReference.kt") + public void testInvokeMemberCallableReference() throws Exception { + runTest("compiler/testData/codegen/box/functions/bigArity/invokeMemberCallableReference.kt"); + } + + @Test + @TestMetadata("nestedBigArityFunCalls.kt") + public void testNestedBigArityFunCalls() throws Exception { + runTest("compiler/testData/codegen/box/functions/bigArity/nestedBigArityFunCalls.kt"); + } + + @Test + @TestMetadata("subclass.kt") + public void testSubclass() throws Exception { + runTest("compiler/testData/codegen/box/functions/bigArity/subclass.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/functions/functionExpression") + @TestDataPath("$PROJECT_ROOT") + public class FunctionExpression { + @Test + public void testAllFilesPresentInFunctionExpression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/functionExpression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("functionExpression.kt") + public void testFunctionExpression() throws Exception { + runTest("compiler/testData/codegen/box/functions/functionExpression/functionExpression.kt"); + } + + @Test + @TestMetadata("functionExpressionWithThisReference.kt") + public void testFunctionExpressionWithThisReference() throws Exception { + runTest("compiler/testData/codegen/box/functions/functionExpression/functionExpressionWithThisReference.kt"); + } + + @Test + @TestMetadata("functionLiteralExpression.kt") + public void testFunctionLiteralExpression() throws Exception { + runTest("compiler/testData/codegen/box/functions/functionExpression/functionLiteralExpression.kt"); + } + + @Test + @TestMetadata("insideGenericLambda.kt") + public void testInsideGenericLambda() throws Exception { + runTest("compiler/testData/codegen/box/functions/functionExpression/insideGenericLambda.kt"); + } + + @Test + @TestMetadata("underscoreParameters.kt") + public void testUnderscoreParameters() throws Exception { + runTest("compiler/testData/codegen/box/functions/functionExpression/underscoreParameters.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/functions/invoke") + @TestDataPath("$PROJECT_ROOT") + public class Invoke { + @Test + public void testAllFilesPresentInInvoke() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/invoke"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("castFunctionToExtension.kt") + public void testCastFunctionToExtension() throws Exception { + runTest("compiler/testData/codegen/box/functions/invoke/castFunctionToExtension.kt"); + } + + @Test + @TestMetadata("extensionInvokeOnExpr.kt") + public void testExtensionInvokeOnExpr() throws Exception { + runTest("compiler/testData/codegen/box/functions/invoke/extensionInvokeOnExpr.kt"); + } + + @Test + @TestMetadata("implicitInvokeInCompanionObjectWithFunctionalArgument.kt") + public void testImplicitInvokeInCompanionObjectWithFunctionalArgument() throws Exception { + runTest("compiler/testData/codegen/box/functions/invoke/implicitInvokeInCompanionObjectWithFunctionalArgument.kt"); + } + + @Test + @TestMetadata("implicitInvokeWithFunctionLiteralArgument.kt") + public void testImplicitInvokeWithFunctionLiteralArgument() throws Exception { + runTest("compiler/testData/codegen/box/functions/invoke/implicitInvokeWithFunctionLiteralArgument.kt"); + } + + @Test + @TestMetadata("invoke.kt") + public void testInvoke() throws Exception { + runTest("compiler/testData/codegen/box/functions/invoke/invoke.kt"); + } + + @Test + @TestMetadata("invokeOnExprByConvention.kt") + public void testInvokeOnExprByConvention() throws Exception { + runTest("compiler/testData/codegen/box/functions/invoke/invokeOnExprByConvention.kt"); + } + + @Test + @TestMetadata("kt3189.kt") + public void testKt3189() throws Exception { + runTest("compiler/testData/codegen/box/functions/invoke/kt3189.kt"); + } + + @Test + @TestMetadata("kt3190.kt") + public void testKt3190() throws Exception { + runTest("compiler/testData/codegen/box/functions/invoke/kt3190.kt"); + } + + @Test + @TestMetadata("kt3297.kt") + public void testKt3297() throws Exception { + runTest("compiler/testData/codegen/box/functions/invoke/kt3297.kt"); + } + + @Test + @TestMetadata("kt3450getAndInvoke.kt") + public void testKt3450getAndInvoke() throws Exception { + runTest("compiler/testData/codegen/box/functions/invoke/kt3450getAndInvoke.kt"); + } + + @Test + @TestMetadata("kt3631invokeOnString.kt") + public void testKt3631invokeOnString() throws Exception { + runTest("compiler/testData/codegen/box/functions/invoke/kt3631invokeOnString.kt"); + } + + @Test + @TestMetadata("kt3772.kt") + public void testKt3772() throws Exception { + runTest("compiler/testData/codegen/box/functions/invoke/kt3772.kt"); + } + + @Test + @TestMetadata("kt3821invokeOnThis.kt") + public void testKt3821invokeOnThis() throws Exception { + runTest("compiler/testData/codegen/box/functions/invoke/kt3821invokeOnThis.kt"); + } + + @Test + @TestMetadata("kt3822invokeOnThis.kt") + public void testKt3822invokeOnThis() throws Exception { + runTest("compiler/testData/codegen/box/functions/invoke/kt3822invokeOnThis.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/functions/localFunctions") + @TestDataPath("$PROJECT_ROOT") + public class LocalFunctions { + @Test + public void testAllFilesPresentInLocalFunctions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/functions/localFunctions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("boundTypeParameterInSupertype.kt") + public void testBoundTypeParameterInSupertype() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/boundTypeParameterInSupertype.kt"); + } + + @Test + @TestMetadata("boundTypeParameterInVararg.kt") + public void testBoundTypeParameterInVararg() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/boundTypeParameterInVararg.kt"); + } + + @Test + @TestMetadata("callBetweenLocalFunctions.kt") + public void testCallBetweenLocalFunctions() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/callBetweenLocalFunctions.kt"); + } + + @Test + @TestMetadata("callInlineLocalInLambda.kt") + public void testCallInlineLocalInLambda() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/callInlineLocalInLambda.kt"); + } + + @Test + @TestMetadata("captureUpperBoundedTypeParameter.kt") + public void testCaptureUpperBoundedTypeParameter() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/captureUpperBoundedTypeParameter.kt"); + } + + @Test + @TestMetadata("definedWithinLambda.kt") + public void testDefinedWithinLambda() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/definedWithinLambda.kt"); + } + + @Test + @TestMetadata("definedWithinLambdaInnerUsage1.kt") + public void testDefinedWithinLambdaInnerUsage1() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/definedWithinLambdaInnerUsage1.kt"); + } + + @Test + @TestMetadata("definedWithinLambdaInnerUsage2.kt") + public void testDefinedWithinLambdaInnerUsage2() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/definedWithinLambdaInnerUsage2.kt"); + } + + @Test + @TestMetadata("kt2895.kt") + public void testKt2895() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/kt2895.kt"); + } + + @Test + @TestMetadata("kt3308.kt") + public void testKt3308() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/kt3308.kt"); + } + + @Test + @TestMetadata("kt3978.kt") + public void testKt3978() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/kt3978.kt"); + } + + @Test + @TestMetadata("kt3978_2.kt") + public void testKt3978_2() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/kt3978_2.kt"); + } + + @Test + @TestMetadata("kt4119.kt") + public void testKt4119() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/kt4119.kt"); + } + + @Test + @TestMetadata("kt4119_2.kt") + public void testKt4119_2() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/kt4119_2.kt"); + } + + @Test + @TestMetadata("kt4514.kt") + public void testKt4514() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/kt4514.kt"); + } + + @Test + @TestMetadata("kt4783.kt") + public void testKt4783() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/kt4783.kt"); + } + + @Test + @TestMetadata("kt4784.kt") + public void testKt4784() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/kt4784.kt"); + } + + @Test + @TestMetadata("kt4989.kt") + public void testKt4989() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/kt4989.kt"); + } + + @Test + @TestMetadata("localExtensionOnNullableParameter.kt") + public void testLocalExtensionOnNullableParameter() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/localExtensionOnNullableParameter.kt"); + } + + @Test + @TestMetadata("localFunctionInConstructor.kt") + public void testLocalFunctionInConstructor() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/localFunctionInConstructor.kt"); + } + + @Test + @TestMetadata("localFunctionVsLocalVariable.kt") + public void testLocalFunctionVsLocalVariable() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/localFunctionVsLocalVariable.kt"); + } + + @Test + @TestMetadata("nameClash.kt") + public void testNameClash() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/nameClash.kt"); + } + + @Test + @TestMetadata("nameClashAcrossDifferentContainers.kt") + public void testNameClashAcrossDifferentContainers() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/nameClashAcrossDifferentContainers.kt"); + } + + @Test + @TestMetadata("overloadedLocalFunWithoutClosure.kt") + public void testOverloadedLocalFunWithoutClosure() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunWithoutClosure.kt"); + } + + @Test + @TestMetadata("overloadedLocalFunction.kt") + public void testOverloadedLocalFunction() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction.kt"); + } + + @Test + @TestMetadata("overloadedLocalFunction1.kt") + public void testOverloadedLocalFunction1() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction1.kt"); + } + + @Test + @TestMetadata("overloadedLocalFunction2.kt") + public void testOverloadedLocalFunction2() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction2.kt"); + } + + @Test + @TestMetadata("overloadedLocalFunction3.kt") + public void testOverloadedLocalFunction3() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction3.kt"); + } + + @Test + @TestMetadata("parameterAsDefaultValue.kt") + public void testParameterAsDefaultValue() throws Exception { + runTest("compiler/testData/codegen/box/functions/localFunctions/parameterAsDefaultValue.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ieee754") + @TestDataPath("$PROJECT_ROOT") + public class Ieee754 { + @Test + public void testAllFilesPresentInIeee754() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ieee754"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("anyCastToPrimitiveCompareTo1.kt") + public void testAnyCastToPrimitiveCompareTo1() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/anyCastToPrimitiveCompareTo1.kt"); + } + + @Test + @TestMetadata("anyCastToPrimitiveCompareTo2.kt") + public void testAnyCastToPrimitiveCompareTo2() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/anyCastToPrimitiveCompareTo2.kt"); + } + + @Test + @TestMetadata("anyToReal.kt") + public void testAnyToReal() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/anyToReal.kt"); + } + + @Test + @TestMetadata("asComparableToDouble.kt") + public void testAsComparableToDouble() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/asComparableToDouble.kt"); + } + + @Test + @TestMetadata("asComparableToDouble_properIeeeComparisons.kt") + public void testAsComparableToDouble_properIeeeComparisons() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/asComparableToDouble_properIeeeComparisons.kt"); + } + + @Test + @TestMetadata("comparableToTWithT_properIeeeComparisons.kt") + public void testComparableToTWithT_properIeeeComparisons() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/comparableToTWithT_properIeeeComparisons.kt"); + } + + @Test + @TestMetadata("comparableTypeCast.kt") + public void testComparableTypeCast() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/comparableTypeCast.kt"); + } + + @Test + @TestMetadata("dataClass.kt") + public void testDataClass() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/dataClass.kt"); + } + + @Test + @TestMetadata("differentTypesComparison.kt") + public void testDifferentTypesComparison() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/differentTypesComparison.kt"); + } + + @Test + @TestMetadata("equalsDouble.kt") + public void testEqualsDouble() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/equalsDouble.kt"); + } + + @Test + @TestMetadata("equalsDouble_properIeeeComparisons.kt") + public void testEqualsDouble_properIeeeComparisons() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/equalsDouble_properIeeeComparisons.kt"); + } + + @Test + @TestMetadata("equalsFloat.kt") + public void testEqualsFloat() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/equalsFloat.kt"); + } + + @Test + @TestMetadata("equalsFloat_properIeeeComparisons.kt") + public void testEqualsFloat_properIeeeComparisons() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/equalsFloat_properIeeeComparisons.kt"); + } + + @Test + @TestMetadata("equalsNaN.kt") + public void testEqualsNaN() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/equalsNaN.kt"); + } + + @Test + @TestMetadata("equalsNaN_properIeeeComparisons.kt") + public void testEqualsNaN_properIeeeComparisons() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/equalsNaN_properIeeeComparisons.kt"); + } + + @Test + @TestMetadata("equalsNullableDouble.kt") + public void testEqualsNullableDouble() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/equalsNullableDouble.kt"); + } + + @Test + @TestMetadata("equalsNullableDouble_properIeeeComparisons.kt") + public void testEqualsNullableDouble_properIeeeComparisons() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/equalsNullableDouble_properIeeeComparisons.kt"); + } + + @Test + @TestMetadata("equalsNullableFloat.kt") + public void testEqualsNullableFloat() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/equalsNullableFloat.kt"); + } + + @Test + @TestMetadata("equalsNullableFloat_properIeeeComparisons.kt") + public void testEqualsNullableFloat_properIeeeComparisons() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/equalsNullableFloat_properIeeeComparisons.kt"); + } + + @Test + @TestMetadata("explicitCompareCall.kt") + public void testExplicitCompareCall() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/explicitCompareCall.kt"); + } + + @Test + @TestMetadata("explicitEqualsCall.kt") + public void testExplicitEqualsCall() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/explicitEqualsCall.kt"); + } + + @Test + @TestMetadata("generic.kt") + public void testGeneric() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/generic.kt"); + } + + @Test + @TestMetadata("greaterDouble.kt") + public void testGreaterDouble() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/greaterDouble.kt"); + } + + @Test + @TestMetadata("greaterDouble_properIeeeComparisons.kt") + public void testGreaterDouble_properIeeeComparisons() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/greaterDouble_properIeeeComparisons.kt"); + } + + @Test + @TestMetadata("greaterFloat.kt") + public void testGreaterFloat() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/greaterFloat.kt"); + } + + @Test + @TestMetadata("greaterFloat_properIeeeComparisons.kt") + public void testGreaterFloat_properIeeeComparisons() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/greaterFloat_properIeeeComparisons.kt"); + } + + @Test + @TestMetadata("inline.kt") + public void testInline() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/inline.kt"); + } + + @Test + @TestMetadata("lessDouble.kt") + public void testLessDouble() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/lessDouble.kt"); + } + + @Test + @TestMetadata("lessDouble_properIeeeAndNewInference.kt") + public void testLessDouble_properIeeeAndNewInference() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/lessDouble_properIeeeAndNewInference.kt"); + } + + @Test + @TestMetadata("lessDouble_properIeeeComparisons.kt") + public void testLessDouble_properIeeeComparisons() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/lessDouble_properIeeeComparisons.kt"); + } + + @Test + @TestMetadata("lessFloat.kt") + public void testLessFloat() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/lessFloat.kt"); + } + + @Test + @TestMetadata("lessFloat_properIeeeComparisons.kt") + public void testLessFloat_properIeeeComparisons() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/lessFloat_properIeeeComparisons.kt"); + } + + @Test + @TestMetadata("nullableAnyToReal.kt") + public void testNullableAnyToReal() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/nullableAnyToReal.kt"); + } + + @Test + @TestMetadata("nullableDoubleEquals.kt") + public void testNullableDoubleEquals() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/nullableDoubleEquals.kt"); + } + + @Test + @TestMetadata("nullableDoubleEqualsLV13.kt") + public void testNullableDoubleEqualsLV13() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/nullableDoubleEqualsLV13.kt"); + } + + @Test + @TestMetadata("nullableDoubleNotEquals.kt") + public void testNullableDoubleNotEquals() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/nullableDoubleNotEquals.kt"); + } + + @Test + @TestMetadata("nullableFloatEquals.kt") + public void testNullableFloatEquals() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/nullableFloatEquals.kt"); + } + + @Test + @TestMetadata("nullableFloatNotEquals.kt") + public void testNullableFloatNotEquals() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/nullableFloatNotEquals.kt"); + } + + @Test + @TestMetadata("nullableIntEquals.kt") + public void testNullableIntEquals() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/nullableIntEquals.kt"); + } + + @Test + @TestMetadata("safeCall.kt") + public void testSafeCall() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/safeCall.kt"); + } + + @Test + @TestMetadata("smartCastOnWhenSubjectAfterCheckInBranch_properIeeeComparisons.kt") + public void testSmartCastOnWhenSubjectAfterCheckInBranch_properIeeeComparisons() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/smartCastOnWhenSubjectAfterCheckInBranch_properIeeeComparisons.kt"); + } + + @Test + @TestMetadata("smartCastToDifferentTypesWithNumericPromotion_properIeeeComparisons.kt") + public void testSmartCastToDifferentTypesWithNumericPromotion_properIeeeComparisons() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/smartCastToDifferentTypesWithNumericPromotion_properIeeeComparisons.kt"); + } + + @Test + @TestMetadata("smartCastToDifferentTypes_properIeeeComparisons.kt") + public void testSmartCastToDifferentTypes_properIeeeComparisons() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/smartCastToDifferentTypes_properIeeeComparisons.kt"); + } + + @Test + @TestMetadata("smartCastToDoubleAndComparableToDouble.kt") + public void testSmartCastToDoubleAndComparableToDouble() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/smartCastToDoubleAndComparableToDouble.kt"); + } + + @Test + @TestMetadata("smartCastToInt.kt") + public void testSmartCastToInt() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/smartCastToInt.kt"); + } + + @Test + @TestMetadata("when.kt") + public void testWhen() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/when.kt"); + } + + @Test + @TestMetadata("whenNoSubject.kt") + public void testWhenNoSubject() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/whenNoSubject.kt"); + } + + @Test + @TestMetadata("whenNoSubject_properIeeeComparisons.kt") + public void testWhenNoSubject_properIeeeComparisons() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/whenNoSubject_properIeeeComparisons.kt"); + } + + @Test + @TestMetadata("whenNullableSmartCast.kt") + public void testWhenNullableSmartCast() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/whenNullableSmartCast.kt"); + } + + @Test + @TestMetadata("when_properIeeeComparisons.kt") + public void testWhen_properIeeeComparisons() throws Exception { + runTest("compiler/testData/codegen/box/ieee754/when_properIeeeComparisons.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/increment") + @TestDataPath("$PROJECT_ROOT") + public class Increment { + @Test + public void testAllFilesPresentInIncrement() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/increment"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("argumentWithSideEffects.kt") + public void testArgumentWithSideEffects() throws Exception { + runTest("compiler/testData/codegen/box/increment/argumentWithSideEffects.kt"); + } + + @Test + @TestMetadata("arrayElement.kt") + public void testArrayElement() throws Exception { + runTest("compiler/testData/codegen/box/increment/arrayElement.kt"); + } + + @Test + @TestMetadata("assignPlusOnSmartCast.kt") + public void testAssignPlusOnSmartCast() throws Exception { + runTest("compiler/testData/codegen/box/increment/assignPlusOnSmartCast.kt"); + } + + @Test + @TestMetadata("augmentedAssignmentWithComplexRhs.kt") + public void testAugmentedAssignmentWithComplexRhs() throws Exception { + runTest("compiler/testData/codegen/box/increment/augmentedAssignmentWithComplexRhs.kt"); + } + + @Test + @TestMetadata("classNaryGetSet.kt") + public void testClassNaryGetSet() throws Exception { + runTest("compiler/testData/codegen/box/increment/classNaryGetSet.kt"); + } + + @Test + @TestMetadata("classVarargGetSet.kt") + public void testClassVarargGetSet() throws Exception { + runTest("compiler/testData/codegen/box/increment/classVarargGetSet.kt"); + } + + @Test + @TestMetadata("classVarargGetSetEvaluationOrder.kt") + public void testClassVarargGetSetEvaluationOrder() throws Exception { + runTest("compiler/testData/codegen/box/increment/classVarargGetSetEvaluationOrder.kt"); + } + + @Test + @TestMetadata("classWithGetSet.kt") + public void testClassWithGetSet() throws Exception { + runTest("compiler/testData/codegen/box/increment/classWithGetSet.kt"); + } + + @Test + @TestMetadata("extOnLong.kt") + public void testExtOnLong() throws Exception { + runTest("compiler/testData/codegen/box/increment/extOnLong.kt"); + } + + @Test + @TestMetadata("genericClassWithGetSet.kt") + public void testGenericClassWithGetSet() throws Exception { + runTest("compiler/testData/codegen/box/increment/genericClassWithGetSet.kt"); + } + + @Test + @TestMetadata("kt36956.kt") + public void testKt36956() throws Exception { + runTest("compiler/testData/codegen/box/increment/kt36956.kt"); + } + + @Test + @TestMetadata("memberExtOnLong.kt") + public void testMemberExtOnLong() throws Exception { + runTest("compiler/testData/codegen/box/increment/memberExtOnLong.kt"); + } + + @Test + @TestMetadata("mutableListElement.kt") + public void testMutableListElement() throws Exception { + runTest("compiler/testData/codegen/box/increment/mutableListElement.kt"); + } + + @Test + @TestMetadata("nullable.kt") + public void testNullable() throws Exception { + runTest("compiler/testData/codegen/box/increment/nullable.kt"); + } + + @Test + @TestMetadata("postfixIncrementDoubleSmartCast.kt") + public void testPostfixIncrementDoubleSmartCast() throws Exception { + runTest("compiler/testData/codegen/box/increment/postfixIncrementDoubleSmartCast.kt"); + } + + @Test + @TestMetadata("postfixIncrementOnClass.kt") + public void testPostfixIncrementOnClass() throws Exception { + runTest("compiler/testData/codegen/box/increment/postfixIncrementOnClass.kt"); + } + + @Test + @TestMetadata("postfixIncrementOnClassSmartCast.kt") + public void testPostfixIncrementOnClassSmartCast() throws Exception { + runTest("compiler/testData/codegen/box/increment/postfixIncrementOnClassSmartCast.kt"); + } + + @Test + @TestMetadata("postfixIncrementOnShortSmartCast.kt") + public void testPostfixIncrementOnShortSmartCast() throws Exception { + runTest("compiler/testData/codegen/box/increment/postfixIncrementOnShortSmartCast.kt"); + } + + @Test + @TestMetadata("postfixIncrementOnSmartCast.kt") + public void testPostfixIncrementOnSmartCast() throws Exception { + runTest("compiler/testData/codegen/box/increment/postfixIncrementOnSmartCast.kt"); + } + + @Test + @TestMetadata("postfixNullableClassIncrement.kt") + public void testPostfixNullableClassIncrement() throws Exception { + runTest("compiler/testData/codegen/box/increment/postfixNullableClassIncrement.kt"); + } + + @Test + @TestMetadata("postfixNullableIncrement.kt") + public void testPostfixNullableIncrement() throws Exception { + runTest("compiler/testData/codegen/box/increment/postfixNullableIncrement.kt"); + } + + @Test + @TestMetadata("prefixIncrementOnClass.kt") + public void testPrefixIncrementOnClass() throws Exception { + runTest("compiler/testData/codegen/box/increment/prefixIncrementOnClass.kt"); + } + + @Test + @TestMetadata("prefixIncrementOnClassSmartCast.kt") + public void testPrefixIncrementOnClassSmartCast() throws Exception { + runTest("compiler/testData/codegen/box/increment/prefixIncrementOnClassSmartCast.kt"); + } + + @Test + @TestMetadata("prefixIncrementOnSmartCast.kt") + public void testPrefixIncrementOnSmartCast() throws Exception { + runTest("compiler/testData/codegen/box/increment/prefixIncrementOnSmartCast.kt"); + } + + @Test + @TestMetadata("prefixNullableClassIncrement.kt") + public void testPrefixNullableClassIncrement() throws Exception { + runTest("compiler/testData/codegen/box/increment/prefixNullableClassIncrement.kt"); + } + + @Test + @TestMetadata("prefixNullableIncrement.kt") + public void testPrefixNullableIncrement() throws Exception { + runTest("compiler/testData/codegen/box/increment/prefixNullableIncrement.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inference") + @TestDataPath("$PROJECT_ROOT") + public class Inference { + @Test + public void testAllFilesPresentInInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("approximateNonTopLevelCapturedTypes.kt") + public void testApproximateNonTopLevelCapturedTypes() throws Exception { + runTest("compiler/testData/codegen/box/inference/approximateNonTopLevelCapturedTypes.kt"); + } + + @Test + @TestMetadata("builderInferenceLeakingVariable.kt") + public void testBuilderInferenceLeakingVariable() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInferenceLeakingVariable.kt"); + } + + @Test + @TestMetadata("capturedStarProjection.kt") + public void testCapturedStarProjection() throws Exception { + runTest("compiler/testData/codegen/box/inference/capturedStarProjection.kt"); + } + + @Test + @TestMetadata("capturedTypesSubstitutionIntoAbbreviation.kt") + public void testCapturedTypesSubstitutionIntoAbbreviation() throws Exception { + runTest("compiler/testData/codegen/box/inference/capturedTypesSubstitutionIntoAbbreviation.kt"); + } + + @Test + @TestMetadata("coercionToUnitWithLastLambdaExpression.kt") + public void testCoercionToUnitWithLastLambdaExpression() throws Exception { + runTest("compiler/testData/codegen/box/inference/coercionToUnitWithLastLambdaExpression.kt"); + } + + @Test + @TestMetadata("coerctionToUnitForLastExpressionWithStarProjection.kt") + public void testCoerctionToUnitForLastExpressionWithStarProjection() throws Exception { + runTest("compiler/testData/codegen/box/inference/coerctionToUnitForLastExpressionWithStarProjection.kt"); + } + + @Test + @TestMetadata("earlyReturnInsideCrossinlineLambda.kt") + public void testEarlyReturnInsideCrossinlineLambda() throws Exception { + runTest("compiler/testData/codegen/box/inference/earlyReturnInsideCrossinlineLambda.kt"); + } + + @Test + @TestMetadata("inferenceWithTypeVariableInsideCapturedType.kt") + public void testInferenceWithTypeVariableInsideCapturedType() throws Exception { + runTest("compiler/testData/codegen/box/inference/inferenceWithTypeVariableInsideCapturedType.kt"); + } + + @Test + @TestMetadata("integerLiteralTypeInLamdaReturnType.kt") + public void testIntegerLiteralTypeInLamdaReturnType() throws Exception { + runTest("compiler/testData/codegen/box/inference/integerLiteralTypeInLamdaReturnType.kt"); + } + + @Test + @TestMetadata("kt10822.kt") + public void testKt10822() throws Exception { + runTest("compiler/testData/codegen/box/inference/kt10822.kt"); + } + + @Test + @TestMetadata("kt35684.kt") + public void testKt35684() throws Exception { + runTest("compiler/testData/codegen/box/inference/kt35684.kt"); + } + + @Test + @TestMetadata("kt36446.kt") + public void testKt36446() throws Exception { + runTest("compiler/testData/codegen/box/inference/kt36446.kt"); + } + + @Test + @TestMetadata("kt38664.kt") + public void testKt38664() throws Exception { + runTest("compiler/testData/codegen/box/inference/kt38664.kt"); + } + + @Test + @TestMetadata("kt39824.kt") + public void testKt39824() throws Exception { + runTest("compiler/testData/codegen/box/inference/kt39824.kt"); + } + + @Test + @TestMetadata("kt42042.kt") + public void testKt42042() throws Exception { + runTest("compiler/testData/codegen/box/inference/kt42042.kt"); + } + + @Test + @TestMetadata("kt42130.kt") + public void testKt42130() throws Exception { + runTest("compiler/testData/codegen/box/inference/kt42130.kt"); + } + + @Test + @TestMetadata("kt45118.kt") + public void testKt45118() throws Exception { + runTest("compiler/testData/codegen/box/inference/kt45118.kt"); + } + + @Test + @TestMetadata("kt49838.kt") + public void testKt49838() throws Exception { + runTest("compiler/testData/codegen/box/inference/kt49838.kt"); + } + + @Test + @TestMetadata("lambdaWithStarReturn.kt") + public void testLambdaWithStarReturn() throws Exception { + runTest("compiler/testData/codegen/box/inference/lambdaWithStarReturn.kt"); + } + + @Test + @TestMetadata("lambdasWithExtensionFunctionType.kt") + public void testLambdasWithExtensionFunctionType() throws Exception { + runTest("compiler/testData/codegen/box/inference/lambdasWithExtensionFunctionType.kt"); + } + + @Test + @TestMetadata("lastExpressionOfLambdaWithNothingConstraint.kt") + public void testLastExpressionOfLambdaWithNothingConstraint() throws Exception { + runTest("compiler/testData/codegen/box/inference/lastExpressionOfLambdaWithNothingConstraint.kt"); + } + + @Test + @TestMetadata("mapCollectChainWithNullResult.kt") + public void testMapCollectChainWithNullResult() throws Exception { + runTest("compiler/testData/codegen/box/inference/mapCollectChainWithNullResult.kt"); + } + + @Test + @TestMetadata("noCoercionToUniForNullableLambdaReturnType.kt") + public void testNoCoercionToUniForNullableLambdaReturnType() throws Exception { + runTest("compiler/testData/codegen/box/inference/noCoercionToUniForNullableLambdaReturnType.kt"); + } + + @Test + @TestMetadata("noCoercionToUnitWithEqualityConstraintForNullableReturnType.kt") + public void testNoCoercionToUnitWithEqualityConstraintForNullableReturnType() throws Exception { + runTest("compiler/testData/codegen/box/inference/noCoercionToUnitWithEqualityConstraintForNullableReturnType.kt"); + } + + @Test + @TestMetadata("overrideDefaultProperty.kt") + public void testOverrideDefaultProperty() throws Exception { + runTest("compiler/testData/codegen/box/inference/overrideDefaultProperty.kt"); + } + + @Test + @TestMetadata("overrideGenericDefaultMethod.kt") + public void testOverrideGenericDefaultMethod() throws Exception { + runTest("compiler/testData/codegen/box/inference/overrideGenericDefaultMethod.kt"); + } + + @Test + @TestMetadata("plusAssignInsideLambda.kt") + public void testPlusAssignInsideLambda() throws Exception { + runTest("compiler/testData/codegen/box/inference/plusAssignInsideLambda.kt"); + } + + @Test + @TestMetadata("recursiveConstraintInsideTypeArgumentWithStarProjection.kt") + public void testRecursiveConstraintInsideTypeArgumentWithStarProjection() throws Exception { + runTest("compiler/testData/codegen/box/inference/recursiveConstraintInsideTypeArgumentWithStarProjection.kt"); + } + + @Test + @TestMetadata("referenceToCatchParameterFromLambdaExpression.kt") + public void testReferenceToCatchParameterFromLambdaExpression() throws Exception { + runTest("compiler/testData/codegen/box/inference/referenceToCatchParameterFromLambdaExpression.kt"); + } + + @Test + @TestMetadata("specialCallsWithCallableReferences.kt") + public void testSpecialCallsWithCallableReferences() throws Exception { + runTest("compiler/testData/codegen/box/inference/specialCallsWithCallableReferences.kt"); + } + + @Test + @TestMetadata("sumOfOverloads.kt") + public void testSumOfOverloads() throws Exception { + runTest("compiler/testData/codegen/box/inference/sumOfOverloads.kt"); + } + + @Test + @TestMetadata("suspendExtensionRecevierFromConstraint.kt") + public void testSuspendExtensionRecevierFromConstraint() throws Exception { + runTest("compiler/testData/codegen/box/inference/suspendExtensionRecevierFromConstraint.kt"); + } + + @Test + @TestMetadata("unsafeVarianceCodegen.kt") + public void testUnsafeVarianceCodegen() throws Exception { + runTest("compiler/testData/codegen/box/inference/unsafeVarianceCodegen.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inference/builderInference") + @TestDataPath("$PROJECT_ROOT") + public class BuilderInference { + @Test + public void testAllFilesPresentInBuilderInference() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inference/builderInference"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("builderCallAsReturnTypeInLocalClass.kt") + public void testBuilderCallAsReturnTypeInLocalClass() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/builderCallAsReturnTypeInLocalClass.kt"); + } + + @Test + @TestMetadata("callableReferenceAndCoercionToUnit.kt") + public void testCallableReferenceAndCoercionToUnit() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/callableReferenceAndCoercionToUnit.kt"); + } + + @Test + @TestMetadata("callableReferencesProperCompletion.kt") + public void testCallableReferencesProperCompletion() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/callableReferencesProperCompletion.kt"); + } + + @Test + @TestMetadata("capturedTypes.kt") + public void testCapturedTypes() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/capturedTypes.kt"); + } + + @Test + @TestMetadata("changingResolveIfDontUseBuilderInferenceDisabledFeature.kt") + public void testChangingResolveIfDontUseBuilderInferenceDisabledFeature() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/changingResolveIfDontUseBuilderInferenceDisabledFeature.kt"); + } + + @Test + @TestMetadata("constraintsBetweenTwoStubVariables.kt") + public void testConstraintsBetweenTwoStubVariables() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/constraintsBetweenTwoStubVariables.kt"); + } + + @Test + @TestMetadata("kt41164.kt") + public void testKt41164() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/kt41164.kt"); + } + + @Test + @TestMetadata("kt42139.kt") + public void testKt42139() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/kt42139.kt"); + } + + @Test + @TestMetadata("kt44241.kt") + public void testKt44241() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/kt44241.kt"); + } + + @Test + @TestMetadata("kt45083.kt") + public void testKt45083() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/kt45083.kt"); + } + + @Test + @TestMetadata("kt47052.kt") + public void testKt47052() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/kt47052.kt"); + } + + @Test + @TestMetadata("kt47744.kt") + public void testKt47744() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/kt47744.kt"); + } + + @Test + @TestMetadata("kt49887.kt") + public void testKt49887() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/kt49887.kt"); + } + + @Test + @TestMetadata("kt51988.kt") + public void testKt51988() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/kt51988.kt"); + } + + @Test + @TestMetadata("labaledCall.kt") + public void testLabaledCall() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/labaledCall.kt"); + } + + @Test + @TestMetadata("lackOfNullCheckOnNullableInsideBuild.kt") + public void testLackOfNullCheckOnNullableInsideBuild() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/lackOfNullCheckOnNullableInsideBuild.kt"); + } + + @Test + @TestMetadata("memberScope.kt") + public void testMemberScope() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/memberScope.kt"); + } + + @Test + @TestMetadata("nullability.kt") + public void testNullability() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/nullability.kt"); + } + + @Test + @TestMetadata("propagateInferenceSessionIntoDeclarationAnalyzers.kt") + public void testPropagateInferenceSessionIntoDeclarationAnalyzers() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/propagateInferenceSessionIntoDeclarationAnalyzers.kt"); + } + + @Test + @TestMetadata("specialCallsWithCallableReferences.kt") + public void testSpecialCallsWithCallableReferences() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferences.kt"); + } + + @Test + @TestMetadata("specialCallsWithCallableReferencesDontRewriteAtSlice.kt") + public void testSpecialCallsWithCallableReferencesDontRewriteAtSlice() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesDontRewriteAtSlice.kt"); + } + + @Test + @TestMetadata("specialCallsWithCallableReferencesErrorType.kt") + public void testSpecialCallsWithCallableReferencesErrorType() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithCallableReferencesErrorType.kt"); + } + + @Test + @TestMetadata("specialCallsWithLambdas.kt") + public void testSpecialCallsWithLambdas() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/specialCallsWithLambdas.kt"); + } + + @Test + @TestMetadata("substituteStubTypeIntoCR.kt") + public void testSubstituteStubTypeIntoCR() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/substituteStubTypeIntoCR.kt"); + } + + @Test + @TestMetadata("substituteStubTypeIntolambdaParameterDescriptor.kt") + public void testSubstituteStubTypeIntolambdaParameterDescriptor() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/substituteStubTypeIntolambdaParameterDescriptor.kt"); + } + + @Test + @TestMetadata("substitutelambdaExtensionReceiverType.kt") + public void testSubstitutelambdaExtensionReceiverType() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/substitutelambdaExtensionReceiverType.kt"); + } + + @Test + @TestMetadata("topDownCompletionBreakedByNonBuilderInferenceSession.kt") + public void testTopDownCompletionBreakedByNonBuilderInferenceSession() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/topDownCompletionBreakedByNonBuilderInferenceSession.kt"); + } + + @Test + @TestMetadata("topDownCompletionWithThreeBuilderInferenceCalls.kt") + public void testTopDownCompletionWithThreeBuilderInferenceCalls() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/topDownCompletionWithThreeBuilderInferenceCalls.kt"); + } + + @Test + @TestMetadata("topDownCompletionWithThreeBuilderInferenceCallsSameLevel.kt") + public void testTopDownCompletionWithThreeBuilderInferenceCallsSameLevel() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/topDownCompletionWithThreeBuilderInferenceCallsSameLevel.kt"); + } + + @Test + @TestMetadata("topDownCompletionWithTwoBuilderInferenceCalls.kt") + public void testTopDownCompletionWithTwoBuilderInferenceCalls() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/topDownCompletionWithTwoBuilderInferenceCalls.kt"); + } + + @Test + @TestMetadata("withExpectedType.kt") + public void testWithExpectedType() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/withExpectedType.kt"); + } + + @Test + @TestMetadata("withoutAnnotation.kt") + public void testWithoutAnnotation() throws Exception { + runTest("compiler/testData/codegen/box/inference/builderInference/withoutAnnotation.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineArgsInPlace") + @TestDataPath("$PROJECT_ROOT") + public class InlineArgsInPlace { + @Test + public void testAllFilesPresentInInlineArgsInPlace() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineArgsInPlace"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("arrayDequeRemoveAll.kt") + public void testArrayDequeRemoveAll() throws Exception { + runTest("compiler/testData/codegen/box/inlineArgsInPlace/arrayDequeRemoveAll.kt"); + } + + @Test + @TestMetadata("breakInArgumentExpression.kt") + public void testBreakInArgumentExpression() throws Exception { + runTest("compiler/testData/codegen/box/inlineArgsInPlace/breakInArgumentExpression.kt"); + } + + @Test + @TestMetadata("continueInArgumentExpression.kt") + public void testContinueInArgumentExpression() throws Exception { + runTest("compiler/testData/codegen/box/inlineArgsInPlace/continueInArgumentExpression.kt"); + } + + @Test + @TestMetadata("inlineCircularDedepency.kt") + public void testInlineCircularDedepency() throws Exception { + runTest("compiler/testData/codegen/box/inlineArgsInPlace/inlineCircularDedepency.kt"); + } + + @Test + @TestMetadata("kotlinReflect.kt") + public void testKotlinReflect() throws Exception { + runTest("compiler/testData/codegen/box/inlineArgsInPlace/kotlinReflect.kt"); + } + + @Test + @TestMetadata("kt49370.kt") + public void testKt49370() throws Exception { + runTest("compiler/testData/codegen/box/inlineArgsInPlace/kt49370.kt"); + } + + @Test + @TestMetadata("kt49407.kt") + public void testKt49407() throws Exception { + runTest("compiler/testData/codegen/box/inlineArgsInPlace/kt49407.kt"); + } + + @Test + @TestMetadata("mapSet.kt") + public void testMapSet() throws Exception { + runTest("compiler/testData/codegen/box/inlineArgsInPlace/mapSet.kt"); + } + + @Test + @TestMetadata("mutableCollectionPlusAssign.kt") + public void testMutableCollectionPlusAssign() throws Exception { + runTest("compiler/testData/codegen/box/inlineArgsInPlace/mutableCollectionPlusAssign.kt"); + } + + @Test + @TestMetadata("noinlineParameter.kt") + public void testNoinlineParameter() throws Exception { + runTest("compiler/testData/codegen/box/inlineArgsInPlace/noinlineParameter.kt"); + } + + @Test + @TestMetadata("suspensionPointInsideArgument.kt") + public void testSuspensionPointInsideArgument() throws Exception { + runTest("compiler/testData/codegen/box/inlineArgsInPlace/suspensionPointInsideArgument.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses") + @TestDataPath("$PROJECT_ROOT") + public class InlineClasses { + @Test + public void testAllFilesPresentInInlineClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("annotatedMemberExtensionProperty.kt") + public void testAnnotatedMemberExtensionProperty() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/annotatedMemberExtensionProperty.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("annotatedMemberExtensionPropertyGeneric.kt") + public void testAnnotatedMemberExtensionPropertyGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/annotatedMemberExtensionPropertyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("anySuperCall.kt") + public void testAnySuperCall() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/anySuperCall.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("anySuperCallGeneric.kt") + public void testAnySuperCallGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/anySuperCallGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boundCallableReferencePassedToInlineFunction.kt") + public void testBoundCallableReferencePassedToInlineFunction() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boundCallableReferencePassedToInlineFunction.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boundCallableReferencePassedToInlineFunctionGeneric.kt") + public void testBoundCallableReferencePassedToInlineFunctionGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boundCallableReferencePassedToInlineFunctionGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boundCallableReferencePassedToInlineFunctionGeneric2.kt") + public void testBoundCallableReferencePassedToInlineFunctionGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boundCallableReferencePassedToInlineFunctionGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxImplDoesNotExecuteInSecondaryConstructor.kt") + public void testBoxImplDoesNotExecuteInSecondaryConstructor() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxImplDoesNotExecuteInSecondaryConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxImplDoesNotExecuteInSecondaryConstructorGeneric.kt") + public void testBoxImplDoesNotExecuteInSecondaryConstructorGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxImplDoesNotExecuteInSecondaryConstructorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxImplDoesNotExecuteInitBlock.kt") + public void testBoxImplDoesNotExecuteInitBlock() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxImplDoesNotExecuteInitBlock.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxImplDoesNotExecuteInitBlockGeneric.kt") + public void testBoxImplDoesNotExecuteInitBlockGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxImplDoesNotExecuteInitBlockGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableForFakeOverride.kt") + public void testBoxNullableForFakeOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxNullableForFakeOverride.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableForFakeOverrideGeneric.kt") + public void testBoxNullableForFakeOverrideGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxNullableForFakeOverrideGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableForFakeOverrideGeneric2.kt") + public void testBoxNullableForFakeOverrideGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxNullableForFakeOverrideGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableValueOfInlineClassWithNonNullUnderlyingType.kt") + public void testBoxNullableValueOfInlineClassWithNonNullUnderlyingType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxNullableValueOfInlineClassWithNonNullUnderlyingType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableValueOfInlineClassWithNonNullUnderlyingTypeGeneric.kt") + public void testBoxNullableValueOfInlineClassWithNonNullUnderlyingTypeGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxNullableValueOfInlineClassWithNonNullUnderlyingTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableValueOfInlineClassWithNonNullUnderlyingTypeGeneric2.kt") + public void testBoxNullableValueOfInlineClassWithNonNullUnderlyingTypeGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxNullableValueOfInlineClassWithNonNullUnderlyingTypeGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableValueOfInlineClassWithPrimitiveUnderlyingType.kt") + public void testBoxNullableValueOfInlineClassWithPrimitiveUnderlyingType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxNullableValueOfInlineClassWithPrimitiveUnderlyingType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableValueOfInlineClassWithPrimitiveUnderlyingTypeGeneric.kt") + public void testBoxNullableValueOfInlineClassWithPrimitiveUnderlyingTypeGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxNullableValueOfInlineClassWithPrimitiveUnderlyingTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableValueOfInlineClassWithPrimitiveUnderlyingTypeGeneric2.kt") + public void testBoxNullableValueOfInlineClassWithPrimitiveUnderlyingTypeGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxNullableValueOfInlineClassWithPrimitiveUnderlyingTypeGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxResultInlineClassOfConstructorCall.kt") + public void testBoxResultInlineClassOfConstructorCall() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxResultInlineClassOfConstructorCall.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxResultInlineClassOfConstructorCallGeneric.kt") + public void testBoxResultInlineClassOfConstructorCallGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxResultInlineClassOfConstructorCallGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxResultInlineClassOfConstructorCallGeneric2.kt") + public void testBoxResultInlineClassOfConstructorCallGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxResultInlineClassOfConstructorCallGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxUnboxInlineClassesWithOperatorsGetSet.kt") + public void testBoxUnboxInlineClassesWithOperatorsGetSet() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxUnboxInlineClassesWithOperatorsGetSet.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxUnboxInlineClassesWithOperatorsGetSetGeneric.kt") + public void testBoxUnboxInlineClassesWithOperatorsGetSetGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxUnboxInlineClassesWithOperatorsGetSetGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxUnboxOfInlineClassForCapturedVars.kt") + public void testBoxUnboxOfInlineClassForCapturedVars() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxUnboxOfInlineClassForCapturedVars.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxUnboxOfInlineClassForCapturedVarsGeneric.kt") + public void testBoxUnboxOfInlineClassForCapturedVarsGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxUnboxOfInlineClassForCapturedVarsGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("bridgeForFunctionReturningInlineClass.kt") + public void testBridgeForFunctionReturningInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/bridgeForFunctionReturningInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("bridgeForFunctionReturningInlineClassGeneric.kt") + public void testBridgeForFunctionReturningInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/bridgeForFunctionReturningInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("bridgeGenerationWithInlineClassOverAny.kt") + public void testBridgeGenerationWithInlineClassOverAny() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/bridgeGenerationWithInlineClassOverAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("bridgeGenerationWithInlineClassOverAnyGeneric.kt") + public void testBridgeGenerationWithInlineClassOverAnyGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/bridgeGenerationWithInlineClassOverAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("bridgeGenerationWithInlineClassOverAnyGeneric2.kt") + public void testBridgeGenerationWithInlineClassOverAnyGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/bridgeGenerationWithInlineClassOverAnyGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("bridgesWhenInlineClassImplementsGenericInterface.kt") + public void testBridgesWhenInlineClassImplementsGenericInterface() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/bridgesWhenInlineClassImplementsGenericInterface.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("bridgesWhenInlineClassImplementsGenericInterfaceGeneric.kt") + public void testBridgesWhenInlineClassImplementsGenericInterfaceGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/bridgesWhenInlineClassImplementsGenericInterfaceGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("callComputablePropertyInsideInlineClass.kt") + public void testCallComputablePropertyInsideInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callComputablePropertyInsideInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("callableReferencesWithInlineClasses.kt") + public void testCallableReferencesWithInlineClasses() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferencesWithInlineClasses.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("callableReferencesWithInlineClassesGeneric.kt") + public void testCallableReferencesWithInlineClassesGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferencesWithInlineClassesGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("castInsideWhenExpression.kt") + public void testCastInsideWhenExpression() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/castInsideWhenExpression.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("castInsideWhenExpressionGeneric.kt") + public void testCastInsideWhenExpressionGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/castInsideWhenExpressionGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkBoxUnboxOfArgumentsOnInlinedFunctions.kt") + public void testCheckBoxUnboxOfArgumentsOnInlinedFunctions() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkBoxUnboxOfArgumentsOnInlinedFunctions.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkBoxUnboxOfArgumentsOnInlinedFunctionsGeneric.kt") + public void testCheckBoxUnboxOfArgumentsOnInlinedFunctionsGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkBoxUnboxOfArgumentsOnInlinedFunctionsGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkBoxingAfterAssertionOperator.kt") + public void testCheckBoxingAfterAssertionOperator() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingAfterAssertionOperator.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkBoxingAfterAssertionOperatorGeneric.kt") + public void testCheckBoxingAfterAssertionOperatorGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingAfterAssertionOperatorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkBoxingForComplexClassHierarchy.kt") + public void testCheckBoxingForComplexClassHierarchy() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingForComplexClassHierarchy.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkBoxingForComplexClassHierarchyGeneric.kt") + public void testCheckBoxingForComplexClassHierarchyGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingForComplexClassHierarchyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkBoxingForNonLocalAndLabeledReturns.kt") + public void testCheckBoxingForNonLocalAndLabeledReturns() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingForNonLocalAndLabeledReturns.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkBoxingForNonLocalAndLabeledReturnsGeneric.kt") + public void testCheckBoxingForNonLocalAndLabeledReturnsGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingForNonLocalAndLabeledReturnsGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkBoxingFromReturnTypeForInlineClasses.kt") + public void testCheckBoxingFromReturnTypeForInlineClasses() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingFromReturnTypeForInlineClasses.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkBoxingFromReturnTypeForInlineClassesGeneric.kt") + public void testCheckBoxingFromReturnTypeForInlineClassesGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingFromReturnTypeForInlineClassesGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkBoxingOnFunctionCalls.kt") + public void testCheckBoxingOnFunctionCalls() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingOnFunctionCalls.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkBoxingOnFunctionCallsGeneric.kt") + public void testCheckBoxingOnFunctionCallsGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingOnFunctionCallsGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkBoxingOnLocalVariableAssignments.kt") + public void testCheckBoxingOnLocalVariableAssignments() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingOnLocalVariableAssignments.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkBoxingOnLocalVariableAssignmentsGeneric.kt") + public void testCheckBoxingOnLocalVariableAssignmentsGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingOnLocalVariableAssignmentsGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkBoxingUnboxingForInheritedTypeSpecializedFunctions.kt") + public void testCheckBoxingUnboxingForInheritedTypeSpecializedFunctions() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingUnboxingForInheritedTypeSpecializedFunctions.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkBoxingUnboxingForInheritedTypeSpecializedFunctionsGeneric.kt") + public void testCheckBoxingUnboxingForInheritedTypeSpecializedFunctionsGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkBoxingUnboxingForInheritedTypeSpecializedFunctionsGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkCallingMembersInsideInlineClass.kt") + public void testCheckCallingMembersInsideInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkCallingMembersInsideInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkCallingMembersInsideInlineClassGeneric.kt") + public void testCheckCallingMembersInsideInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkCallingMembersInsideInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkCastToInlineClass.kt") + public void testCheckCastToInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkCastToInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkCastToInlineClassGeneric.kt") + public void testCheckCastToInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkCastToInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkForInstanceOfInlineClass.kt") + public void testCheckForInstanceOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkForInstanceOfInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkForInstanceOfInlineClassGeneric.kt") + public void testCheckForInstanceOfInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkForInstanceOfInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkLambdaWithInlineClassesInFunctionalType.kt") + public void testCheckLambdaWithInlineClassesInFunctionalType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkLambdaWithInlineClassesInFunctionalType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkLambdaWithInlineClassesInFunctionalTypeGeneric.kt") + public void testCheckLambdaWithInlineClassesInFunctionalTypeGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkLambdaWithInlineClassesInFunctionalTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkUnboxingResultFromTypeVariable.kt") + public void testCheckUnboxingResultFromTypeVariable() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkUnboxingResultFromTypeVariable.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkUnboxingResultFromTypeVariableGeneric.kt") + public void testCheckUnboxingResultFromTypeVariableGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkUnboxingResultFromTypeVariableGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("checkUnboxingResultFromTypeVariableGeneric2.kt") + public void testCheckUnboxingResultFromTypeVariableGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/checkUnboxingResultFromTypeVariableGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("classInInlineClassInit.kt") + public void testClassInInlineClassInit() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/classInInlineClassInit.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("classInInlineClassInitGeneric.kt") + public void testClassInInlineClassInitGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/classInInlineClassInitGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("computablePropertyInsideInlineClass.kt") + public void testComputablePropertyInsideInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/computablePropertyInsideInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("conformToComparableAndCallInterfaceMethod.kt") + public void testConformToComparableAndCallInterfaceMethod() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/conformToComparableAndCallInterfaceMethod.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("conformToComparableAndCallInterfaceMethodGeneric.kt") + public void testConformToComparableAndCallInterfaceMethodGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/conformToComparableAndCallInterfaceMethodGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("constructorCallableReference.kt") + public void testConstructorCallableReference() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/constructorCallableReference.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("constructorCallableReferenceGeneric.kt") + public void testConstructorCallableReferenceGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/constructorCallableReferenceGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("correctBoxingForBranchExpressions.kt") + public void testCorrectBoxingForBranchExpressions() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/correctBoxingForBranchExpressions.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("correctBoxingForBranchExpressionsGeneric.kt") + public void testCorrectBoxingForBranchExpressionsGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/correctBoxingForBranchExpressionsGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("createInlineClassInArgumentPosition.kt") + public void testCreateInlineClassInArgumentPosition() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/createInlineClassInArgumentPosition.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("createInlineClassInArgumentPositionGeneric.kt") + public void testCreateInlineClassInArgumentPositionGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/createInlineClassInArgumentPositionGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("crossinlineWithInlineClassInParameter.kt") + public void testCrossinlineWithInlineClassInParameter() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/crossinlineWithInlineClassInParameter.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("crossinlineWithInlineClassInParameterGeneric.kt") + public void testCrossinlineWithInlineClassInParameterGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/crossinlineWithInlineClassInParameterGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("crossinlineWithInlineClassInParameterGeneric2.kt") + public void testCrossinlineWithInlineClassInParameterGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/crossinlineWithInlineClassInParameterGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("customIterator.kt") + public void testCustomIterator() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/customIterator.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("defaultFunctionsFromAnyForInlineClass.kt") + public void testDefaultFunctionsFromAnyForInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultFunctionsFromAnyForInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("defaultFunctionsFromAnyForInlineClassGeneric.kt") + public void testDefaultFunctionsFromAnyForInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultFunctionsFromAnyForInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("defaultInterfaceMethodsInInlineClass.kt") + public void testDefaultInterfaceMethodsInInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultInterfaceMethodsInInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("defaultInterfaceMethodsInInlineClassGeneric.kt") + public void testDefaultInterfaceMethodsInInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultInterfaceMethodsInInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("defaultWithInlineClassArgument.kt") + public void testDefaultWithInlineClassArgument() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultWithInlineClassArgument.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("defaultWithInlineClassArgumentGeneric.kt") + public void testDefaultWithInlineClassArgumentGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultWithInlineClassArgumentGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("elvisWithInlineClassAndNullConstant.kt") + public void testElvisWithInlineClassAndNullConstant() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/elvisWithInlineClassAndNullConstant.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("elvisWithInlineClassAndNullConstantGeneric.kt") + public void testElvisWithInlineClassAndNullConstantGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/elvisWithInlineClassAndNullConstantGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("emptyConstructorForInlineClass.kt") + public void testEmptyConstructorForInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/emptyConstructorForInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("emptyConstructorForInlineClassGeneric.kt") + public void testEmptyConstructorForInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/emptyConstructorForInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalityChecksInlineClassNonNull.kt") + public void testEqualityChecksInlineClassNonNull() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksInlineClassNonNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalityChecksInlineClassNonNullGeneric.kt") + public void testEqualityChecksInlineClassNonNullGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksInlineClassNonNullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalityChecksMixedNullability.kt") + public void testEqualityChecksMixedNullability() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksMixedNullability.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalityChecksMixedNullabilityGeneric.kt") + public void testEqualityChecksMixedNullabilityGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksMixedNullabilityGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalityChecksNegatedInlineClassNonNull.kt") + public void testEqualityChecksNegatedInlineClassNonNull() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNegatedInlineClassNonNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalityChecksNegatedInlineClassNonNullGeneric.kt") + public void testEqualityChecksNegatedInlineClassNonNullGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNegatedInlineClassNonNullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalityChecksNegatedNonNull.kt") + public void testEqualityChecksNegatedNonNull() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNegatedNonNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalityChecksNegatedNonNullGeneric.kt") + public void testEqualityChecksNegatedNonNullGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNegatedNonNullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalityChecksNegatedNullable.kt") + public void testEqualityChecksNegatedNullable() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNegatedNullable.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalityChecksNegatedNullableGeneric.kt") + public void testEqualityChecksNegatedNullableGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNegatedNullableGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalityChecksNegatedNullableGeneric2.kt") + public void testEqualityChecksNegatedNullableGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNegatedNullableGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalityChecksNegatedPrimitive.kt") + public void testEqualityChecksNegatedPrimitive() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNegatedPrimitive.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalityChecksNegatedPrimitiveGeneric.kt") + public void testEqualityChecksNegatedPrimitiveGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNegatedPrimitiveGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalityChecksNonNull.kt") + public void testEqualityChecksNonNull() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNonNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalityChecksNonNullGeneric.kt") + public void testEqualityChecksNonNullGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNonNullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalityChecksNullable.kt") + public void testEqualityChecksNullable() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNullable.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalityChecksNullableGeneric.kt") + public void testEqualityChecksNullableGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNullableGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalityChecksNullableGeneric2.kt") + public void testEqualityChecksNullableGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksNullableGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalityChecksPrimitive.kt") + public void testEqualityChecksPrimitive() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksPrimitive.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalityChecksPrimitiveGeneric.kt") + public void testEqualityChecksPrimitiveGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksPrimitiveGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalityChecksPrimitiveUnboxed.kt") + public void testEqualityChecksPrimitiveUnboxed() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalityChecksPrimitiveUnboxed.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalityForBoxesOfNullableValuesOfInlineClass.kt") + public void testEqualityForBoxesOfNullableValuesOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalityForBoxesOfNullableValuesOfInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalityForBoxesOfNullableValuesOfInlineClassGeneric.kt") + public void testEqualityForBoxesOfNullableValuesOfInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalityForBoxesOfNullableValuesOfInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalsCallsLeftArgument.kt") + public void testEqualsCallsLeftArgument() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalsCallsLeftArgument.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalsCallsLeftArgumentGeneric.kt") + public void testEqualsCallsLeftArgumentGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalsCallsLeftArgumentGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalsEvaluationOrderInlineClass.kt") + public void testEqualsEvaluationOrderInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalsEvaluationOrderInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalsEvaluationOrderInlineClassGeneric.kt") + public void testEqualsEvaluationOrderInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalsEvaluationOrderInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalsEvaluationOrderNonNull.kt") + public void testEqualsEvaluationOrderNonNull() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalsEvaluationOrderNonNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalsEvaluationOrderNonNullGeneric.kt") + public void testEqualsEvaluationOrderNonNullGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalsEvaluationOrderNonNullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalsEvaluationOrderNullable.kt") + public void testEqualsEvaluationOrderNullable() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalsEvaluationOrderNullable.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalsEvaluationOrderNullableGeneric.kt") + public void testEqualsEvaluationOrderNullableGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalsEvaluationOrderNullableGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalsEvaluationOrderNullableGeneric2.kt") + public void testEqualsEvaluationOrderNullableGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalsEvaluationOrderNullableGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalsEvaluationOrderPrimitive.kt") + public void testEqualsEvaluationOrderPrimitive() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalsEvaluationOrderPrimitive.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalsEvaluationOrderPrimitiveGeneric.kt") + public void testEqualsEvaluationOrderPrimitiveGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalsEvaluationOrderPrimitiveGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalsOperatorWithGenericCall.kt") + public void testEqualsOperatorWithGenericCall() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalsOperatorWithGenericCall.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalsOperatorWithGenericCallGeneric.kt") + public void testEqualsOperatorWithGenericCallGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/equalsOperatorWithGenericCallGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("extLambdaInInlineClassFun.kt") + public void testExtLambdaInInlineClassFun() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/extLambdaInInlineClassFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("extLambdaInInlineClassFun2.kt") + public void testExtLambdaInInlineClassFun2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/extLambdaInInlineClassFun2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("extLambdaInInlineClassFun2Generic.kt") + public void testExtLambdaInInlineClassFun2Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/extLambdaInInlineClassFun2Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("extLambdaInInlineClassFunGeneric.kt") + public void testExtLambdaInInlineClassFunGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/extLambdaInInlineClassFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("fieldNameClash.kt") + public void testFieldNameClash() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/fieldNameClash.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("fieldNameClashGeneric.kt") + public void testFieldNameClashGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/fieldNameClashGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("funInterfaceDoubleSuffux.kt") + public void testFunInterfaceDoubleSuffux() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterfaceDoubleSuffux.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("funInterfaceDoubleSuffux2.kt") + public void testFunInterfaceDoubleSuffux2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterfaceDoubleSuffux2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("functionExpression.kt") + public void testFunctionExpression() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionExpression.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("functionExpressionGeneric.kt") + public void testFunctionExpressionGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionExpressionGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("genericInlineClassSynthMembers.kt") + public void testGenericInlineClassSynthMembers() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/genericInlineClassSynthMembers.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("genericVararg2ndConstructor.kt") + public void testGenericVararg2ndConstructor() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/genericVararg2ndConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("initBlock.kt") + public void testInitBlock() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/initBlock.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("initBlockGeneric.kt") + public void testInitBlockGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/initBlockGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("initInCompanion.kt") + public void testInitInCompanion() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/initInCompanion.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassAsLastExpressionInInLambda.kt") + public void testInlineClassAsLastExpressionInInLambda() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassAsLastExpressionInInLambda.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassAsLastExpressionInInLambdaGeneric.kt") + public void testInlineClassAsLastExpressionInInLambdaGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassAsLastExpressionInInLambdaGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassEqualityShouldUseTotalOrderForFloatingPointData.kt") + public void testInlineClassEqualityShouldUseTotalOrderForFloatingPointData() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassEqualityShouldUseTotalOrderForFloatingPointData.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassEqualityShouldUseTotalOrderForFloatingPointDataGeneric.kt") + public void testInlineClassEqualityShouldUseTotalOrderForFloatingPointDataGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassEqualityShouldUseTotalOrderForFloatingPointDataGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassFieldHandling.kt") + public void testInlineClassFieldHandling() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassFieldHandling.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassFieldHandlingGeneric.kt") + public void testInlineClassFieldHandlingGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassFieldHandlingGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassFunctionInvoke.kt") + public void testInlineClassFunctionInvoke() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassFunctionInvoke.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassFunctionInvokeGeneric.kt") + public void testInlineClassFunctionInvokeGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassFunctionInvokeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassHashCodeOverride.kt") + public void testInlineClassHashCodeOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassHashCodeOverride.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassInInitBlock.kt") + public void testInlineClassInInitBlock() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassInInitBlock.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassInInitBlockGeneric.kt") + public void testInlineClassInInitBlockGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassInInitBlockGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassInStringTemplate.kt") + public void testInlineClassInStringTemplate() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassInStringTemplate.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassInStringTemplateGeneric.kt") + public void testInlineClassInStringTemplateGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassInStringTemplateGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassPropertyReferenceGetAndSet.kt") + public void testInlineClassPropertyReferenceGetAndSet() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassPropertyReferenceGetAndSet.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassPropertyReferenceGetAndSetGeneric.kt") + public void testInlineClassPropertyReferenceGetAndSetGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassPropertyReferenceGetAndSetGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassValueCapturedInInlineLambda.kt") + public void testInlineClassValueCapturedInInlineLambda() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassValueCapturedInInlineLambda.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassValueCapturedInInlineLambdaGeneric.kt") + public void testInlineClassValueCapturedInInlineLambdaGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassValueCapturedInInlineLambdaGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassValueCapturedInNonInlineLambda.kt") + public void testInlineClassValueCapturedInNonInlineLambda() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassValueCapturedInNonInlineLambda.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassValueCapturedInNonInlineLambdaGeneric.kt") + public void testInlineClassValueCapturedInNonInlineLambdaGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassValueCapturedInNonInlineLambdaGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassValuesInsideStrings.kt") + public void testInlineClassValuesInsideStrings() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassValuesInsideStrings.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassValuesInsideStringsGeneric.kt") + public void testInlineClassValuesInsideStringsGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassValuesInsideStringsGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassWithCustomEquals.kt") + public void testInlineClassWithCustomEquals() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassWithCustomEquals.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassWithCustomEqualsGeneric.kt") + public void testInlineClassWithCustomEqualsGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassWithCustomEqualsGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassWithDefaultFunctionsFromAny.kt") + public void testInlineClassWithDefaultFunctionsFromAny() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassWithDefaultFunctionsFromAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassWithDefaultFunctionsFromAnyGeneric.kt") + public void testInlineClassWithDefaultFunctionsFromAnyGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassWithDefaultFunctionsFromAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassesAsInlineFunParameters.kt") + public void testInlineClassesAsInlineFunParameters() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesAsInlineFunParameters.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassesAsInlineFunParametersGeneric.kt") + public void testInlineClassesAsInlineFunParametersGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesAsInlineFunParametersGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassesCheckCast.kt") + public void testInlineClassesCheckCast() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesCheckCast.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassesCheckCastGeneric.kt") + public void testInlineClassesCheckCastGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesCheckCastGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassesInInlineLambdaParameters.kt") + public void testInlineClassesInInlineLambdaParameters() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesInInlineLambdaParameters.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassesInInlineLambdaParametersGeneric.kt") + public void testInlineClassesInInlineLambdaParametersGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesInInlineLambdaParametersGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassesRefTypesInInlineLambdaParameters.kt") + public void testInlineClassesRefTypesInInlineLambdaParameters() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesRefTypesInInlineLambdaParameters.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassesRefTypesInInlineLambdaParametersGeneric.kt") + public void testInlineClassesRefTypesInInlineLambdaParametersGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassesRefTypesInInlineLambdaParametersGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineExtLambdaInInlineClassFun.kt") + public void testInlineExtLambdaInInlineClassFun() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineExtLambdaInInlineClassFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineExtLambdaInInlineClassFun2.kt") + public void testInlineExtLambdaInInlineClassFun2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineExtLambdaInInlineClassFun2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineExtLambdaInInlineClassFun2Generic.kt") + public void testInlineExtLambdaInInlineClassFun2Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineExtLambdaInInlineClassFun2Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineExtLambdaInInlineClassFunGeneric.kt") + public void testInlineExtLambdaInInlineClassFunGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineExtLambdaInInlineClassFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineFunctionInsideInlineClass.kt") + public void testInlineFunctionInsideInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineFunctionInsideInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineFunctionInsideInlineClassGeneric.kt") + public void testInlineFunctionInsideInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineFunctionInsideInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("iterateOverArrayOfInlineClassValues.kt") + public void testIterateOverArrayOfInlineClassValues() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/iterateOverArrayOfInlineClassValues.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("iterateOverArrayOfInlineClassValuesGeneric.kt") + public void testIterateOverArrayOfInlineClassValuesGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/iterateOverArrayOfInlineClassValuesGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("iterateOverListOfInlineClassValues.kt") + public void testIterateOverListOfInlineClassValues() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/iterateOverListOfInlineClassValues.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("iterateOverListOfInlineClassValuesGeneric.kt") + public void testIterateOverListOfInlineClassValuesGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/iterateOverListOfInlineClassValuesGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("jvmInline.kt") + public void testJvmInline() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/jvmInline.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt25246.kt") + public void testKt25246() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt25246.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt25750.kt") + public void testKt25750() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt25750.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt25750Generic.kt") + public void testKt25750Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt25750Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt25771.kt") + public void testKt25771() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt25771.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt26103.kt") + public void testKt26103() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt26103.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt26103_contravariantUnderlyingType.kt") + public void testKt26103_contravariantUnderlyingType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt26103_contravariantUnderlyingType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt26103_covariantUnderlyingType.kt") + public void testKt26103_covariantUnderlyingType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt26103_covariantUnderlyingType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt26103_original.kt") + public void testKt26103_original() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt26103_original.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27096.kt") + public void testKt27096() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27096.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27096Generic.kt") + public void testKt27096Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27096Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27096_enum.kt") + public void testKt27096_enum() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27096_enum.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27096_enumGeneric.kt") + public void testKt27096_enumGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27096_enumGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27096_functional.kt") + public void testKt27096_functional() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27096_functional.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27096_functionalGeneric.kt") + public void testKt27096_functionalGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27096_functionalGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27096_innerClass.kt") + public void testKt27096_innerClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27096_innerClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27096_nullablePrimitive.kt") + public void testKt27096_nullablePrimitive() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27096_nullablePrimitive.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27096_nullablePrimitiveGeneric.kt") + public void testKt27096_nullablePrimitiveGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27096_nullablePrimitiveGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27096_nullablePrimitiveGeneric2.kt") + public void testKt27096_nullablePrimitiveGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27096_nullablePrimitiveGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27096_nullableReference.kt") + public void testKt27096_nullableReference() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27096_nullableReference.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27096_nullableReferenceGeneric.kt") + public void testKt27096_nullableReferenceGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27096_nullableReferenceGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27096_nullableReferenceGeneric2.kt") + public void testKt27096_nullableReferenceGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27096_nullableReferenceGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27096_primitive.kt") + public void testKt27096_primitive() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27096_primitive.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27096_primitiveGeneric.kt") + public void testKt27096_primitiveGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27096_primitiveGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27096_reference.kt") + public void testKt27096_reference() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27096_reference.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27096_referenceGeneric.kt") + public void testKt27096_referenceGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27096_referenceGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27113.kt") + public void testKt27113() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27113.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27113a.kt") + public void testKt27113a() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27113a.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27113aGeneric.kt") + public void testKt27113aGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27113aGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27132.kt") + public void testKt27132() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27132.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27132Generic.kt") + public void testKt27132Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27132Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27140.kt") + public void testKt27140() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27140.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27140Generic.kt") + public void testKt27140Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27140Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27705.kt") + public void testKt27705() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27705.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27705Generic.kt") + public void testKt27705Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27705Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27706.kt") + public void testKt27706() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27706.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27706Generic.kt") + public void testKt27706Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt27706Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt28405.kt") + public void testKt28405() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt28405.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt28585.kt") + public void testKt28585() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt28585.kt"); + } + + @Test + @TestMetadata("kt31994.kt") + public void testKt31994() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt31994.kt"); + } + + @Test + @TestMetadata("kt32793.kt") + public void testKt32793() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt32793.kt"); + } + + @Test + @TestMetadata("kt33119.kt") + public void testKt33119() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt33119.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt33119Generic.kt") + public void testKt33119Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt33119Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt34268.kt") + public void testKt34268() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt34268.kt"); + } + + @Test + @TestMetadata("kt34902.kt") + public void testKt34902() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt34902.kt"); + } + + @Test + @TestMetadata("kt37998.kt") + public void testKt37998() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt37998.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt37998Generic.kt") + public void testKt37998Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt37998Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt38680.kt") + public void testKt38680() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt38680.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt38680Generic.kt") + public void testKt38680Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt38680Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt38680a.kt") + public void testKt38680a() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt38680a.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt38680aGeneric.kt") + public void testKt38680aGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt38680aGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt38680b.kt") + public void testKt38680b() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt38680b.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt38680bGeneric.kt") + public void testKt38680bGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt38680bGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt44141.kt") + public void testKt44141() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt44141.kt"); + } + + @Test + @TestMetadata("kt44867.kt") + public void testKt44867() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt44867.kt"); + } + + @Test + @TestMetadata("kt44978.kt") + public void testKt44978() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt44978.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt45084.kt") + public void testKt45084() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt45084.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt45084Generic.kt") + public void testKt45084Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt45084Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt45991.kt") + public void testKt45991() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt45991.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt46554.kt") + public void testKt46554() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt46554.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt46554Generic.kt") + public void testKt46554Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt46554Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt47762.kt") + public void testKt47762() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt47762.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt47762Generic.kt") + public void testKt47762Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt47762Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt47823.kt") + public void testKt47823() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt47823.kt"); + } + + @Test + @TestMetadata("kt50974_resultMultiModule.kt") + public void testKt50974_resultMultiModule() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt50974_resultMultiModule.kt"); + } + + @Test + @TestMetadata("kt51157.kt") + public void testKt51157() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt51157.kt"); + } + + @Test + @TestMetadata("kt51254.kt") + public void testKt51254() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt51254.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt52913.kt") + public void testKt52913() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt52913.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt54455.kt") + public void testKt54455() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt54455.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt57973.kt") + public void testKt57973() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/kt57973.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("lateinitInlineClasses.kt") + public void testLateinitInlineClasses() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/lateinitInlineClasses.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("mangledDefaultParameterFunction.kt") + public void testMangledDefaultParameterFunction() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/mangledDefaultParameterFunction.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("mangledDefaultParameterFunctionGeneric.kt") + public void testMangledDefaultParameterFunctionGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/mangledDefaultParameterFunctionGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("mangledSuperCalls.kt") + public void testMangledSuperCalls() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/mangledSuperCalls.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("mangledSuperCallsGeneric.kt") + public void testMangledSuperCallsGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/mangledSuperCallsGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("multifileClass.kt") + public void testMultifileClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/multifileClass.kt"); + } + + @Test + @TestMetadata("nestedInlineClass.kt") + public void testNestedInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/nestedInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("nestedInlineClassGeneric.kt") + public void testNestedInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/nestedInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("noAssertionsOnInlineClassBasedOnNullableType.kt") + public void testNoAssertionsOnInlineClassBasedOnNullableType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/noAssertionsOnInlineClassBasedOnNullableType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("noAssertionsOnInlineClassBasedOnNullableTypeGeneric.kt") + public void testNoAssertionsOnInlineClassBasedOnNullableTypeGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/noAssertionsOnInlineClassBasedOnNullableTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("noReturnTypeMangling.kt") + public void testNoReturnTypeMangling() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/noReturnTypeMangling.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("noReturnTypeManglingGeneric.kt") + public void testNoReturnTypeManglingGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/noReturnTypeManglingGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("nullableEqeqNonNull.kt") + public void testNullableEqeqNonNull() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/nullableEqeqNonNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("nullableEqeqNonNullGeneric.kt") + public void testNullableEqeqNonNullGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/nullableEqeqNonNullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("nullableWrapperEquality.kt") + public void testNullableWrapperEquality() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/nullableWrapperEquality.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("nullableWrapperEqualityGeneric.kt") + public void testNullableWrapperEqualityGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/nullableWrapperEqualityGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("nullableWrapperEqualityGeneric2.kt") + public void testNullableWrapperEqualityGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/nullableWrapperEqualityGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overrideReturnNothing.kt") + public void testOverrideReturnNothing() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/overrideReturnNothing.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overridingFunCallingPrivateFun.kt") + public void testOverridingFunCallingPrivateFun() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/overridingFunCallingPrivateFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overridingFunCallingPrivateFunGeneric.kt") + public void testOverridingFunCallingPrivateFunGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/overridingFunCallingPrivateFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("passInlineClassAsVararg.kt") + public void testPassInlineClassAsVararg() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/passInlineClassAsVararg.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("passInlineClassAsVarargGeneric.kt") + public void testPassInlineClassAsVarargGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/passInlineClassAsVarargGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("passInlineClassWithSpreadOperatorToVarargs.kt") + public void testPassInlineClassWithSpreadOperatorToVarargs() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/passInlineClassWithSpreadOperatorToVarargs.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("passInlineClassWithSpreadOperatorToVarargsGeneric.kt") + public void testPassInlineClassWithSpreadOperatorToVarargsGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/passInlineClassWithSpreadOperatorToVarargsGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("privateConstructorFunInterfaceMultiModule.kt") + public void testPrivateConstructorFunInterfaceMultiModule() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/privateConstructorFunInterfaceMultiModule.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("privateConstructorFunInterfaceMultiModuleGeneric.kt") + public void testPrivateConstructorFunInterfaceMultiModuleGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/privateConstructorFunInterfaceMultiModuleGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("propertyLoweringOrder.kt") + public void testPropertyLoweringOrder() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/propertyLoweringOrder.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("propertyLoweringOrderGeneric.kt") + public void testPropertyLoweringOrderGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/propertyLoweringOrderGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("referToPropertyInCompanionObjectOfInlineClass.kt") + public void testReferToPropertyInCompanionObjectOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/referToPropertyInCompanionObjectOfInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("referToPropertyInCompanionObjectOfInlineClassGeneric.kt") + public void testReferToPropertyInCompanionObjectOfInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/referToPropertyInCompanionObjectOfInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("referToUnderlyingPropertyInsideInlineClass.kt") + public void testReferToUnderlyingPropertyInsideInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/referToUnderlyingPropertyInsideInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("referToUnderlyingPropertyInsideInlineClassGeneric.kt") + public void testReferToUnderlyingPropertyInsideInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/referToUnderlyingPropertyInsideInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("referToUnderlyingPropertyOfInlineClass.kt") + public void testReferToUnderlyingPropertyOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/referToUnderlyingPropertyOfInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("referToUnderlyingPropertyOfInlineClassGeneric.kt") + public void testReferToUnderlyingPropertyOfInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/referToUnderlyingPropertyOfInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("removeInInlineCollectionOfInlineClassAsInt.kt") + public void testRemoveInInlineCollectionOfInlineClassAsInt() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/removeInInlineCollectionOfInlineClassAsInt.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("result.kt") + public void testResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("resultGeneric.kt") + public void testResultGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/resultGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("resultGeneric2.kt") + public void testResultGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/resultGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("resultInlining.kt") + public void testResultInlining() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/resultInlining.kt"); + } + + @Test + @TestMetadata("resultRunCatchingOrElse.kt") + public void testResultRunCatchingOrElse() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/resultRunCatchingOrElse.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("safeAsOfTypeParameterWithInlineClassBound.kt") + public void testSafeAsOfTypeParameterWithInlineClassBound() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/safeAsOfTypeParameterWithInlineClassBound.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("safeAsOfTypeParameterWithInlineClassBoundGeneric.kt") + public void testSafeAsOfTypeParameterWithInlineClassBoundGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/safeAsOfTypeParameterWithInlineClassBoundGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("samWrapperDifferentModule.kt") + public void testSamWrapperDifferentModule() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/samWrapperDifferentModule.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("samWrapperDifferentModuleGeneric.kt") + public void testSamWrapperDifferentModuleGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/samWrapperDifferentModuleGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("secondaryConstructorVisibilies.kt") + public void testSecondaryConstructorVisibilies() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/secondaryConstructorVisibilies.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("secondaryConstructorWithVararg.kt") + public void testSecondaryConstructorWithVararg() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/secondaryConstructorWithVararg.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("secondaryConstructorWithVarargGeneric.kt") + public void testSecondaryConstructorWithVarargGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/secondaryConstructorWithVarargGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("secondaryConstructorsInsideInlineClass.kt") + public void testSecondaryConstructorsInsideInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/secondaryConstructorsInsideInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("secondaryConstructorsInsideInlineClassGeneric.kt") + public void testSecondaryConstructorsInsideInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/secondaryConstructorsInsideInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("secondaryConstructorsInsideInlineClassWithPrimitiveCarrierType.kt") + public void testSecondaryConstructorsInsideInlineClassWithPrimitiveCarrierType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/secondaryConstructorsInsideInlineClassWithPrimitiveCarrierType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("secondaryConstructorsInsideInlineClassWithPrimitiveCarrierTypeGeneric.kt") + public void testSecondaryConstructorsInsideInlineClassWithPrimitiveCarrierTypeGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/secondaryConstructorsInsideInlineClassWithPrimitiveCarrierTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("secondaryConstructorsWithBody.kt") + public void testSecondaryConstructorsWithBody() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/secondaryConstructorsWithBody.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("simpleSecondaryConstructor.kt") + public void testSimpleSecondaryConstructor() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/simpleSecondaryConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("simpleSecondaryConstructorGeneric.kt") + public void testSimpleSecondaryConstructorGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/simpleSecondaryConstructorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("smartCastOnThisOfInlineClassType.kt") + public void testSmartCastOnThisOfInlineClassType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/smartCastOnThisOfInlineClassType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("smartCastOnThisOfInlineClassTypeGeneric.kt") + public void testSmartCastOnThisOfInlineClassTypeGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/smartCastOnThisOfInlineClassTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("stringPlus.kt") + public void testStringPlus() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/stringPlus.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("stringPlusGeneric.kt") + public void testStringPlusGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/stringPlusGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("toStringCallingPrivateFun.kt") + public void testToStringCallingPrivateFun() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/toStringCallingPrivateFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("toStringCallingPrivateFunGeneric.kt") + public void testToStringCallingPrivateFunGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/toStringCallingPrivateFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("toStringOfUnboxedNullable.kt") + public void testToStringOfUnboxedNullable() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/toStringOfUnboxedNullable.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("toStringOfUnboxedNullableGeneric.kt") + public void testToStringOfUnboxedNullableGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/toStringOfUnboxedNullableGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("typeChecksForInlineClasses.kt") + public void testTypeChecksForInlineClasses() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/typeChecksForInlineClasses.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("typeChecksForInlineClassesGeneric.kt") + public void testTypeChecksForInlineClassesGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/typeChecksForInlineClassesGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("UIntArraySortExample.kt") + public void testUIntArraySortExample() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/UIntArraySortExample.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("UIntArraySortExampleGeneric.kt") + public void testUIntArraySortExampleGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/UIntArraySortExampleGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("UIntSafeAsInt.kt") + public void testUIntSafeAsInt() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/UIntSafeAsInt.kt"); + } + + @Test + @TestMetadata("unboxNullableValueOfInlineClassWithNonNullUnderlyingType.kt") + public void testUnboxNullableValueOfInlineClassWithNonNullUnderlyingType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxNullableValueOfInlineClassWithNonNullUnderlyingType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("unboxNullableValueOfInlineClassWithNonNullUnderlyingTypeGeneric.kt") + public void testUnboxNullableValueOfInlineClassWithNonNullUnderlyingTypeGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxNullableValueOfInlineClassWithNonNullUnderlyingTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("unboxNullableValueOfInlineClassWithNullableInlineClassUnderlyingTypeGWI.kt") + public void testUnboxNullableValueOfInlineClassWithNullableInlineClassUnderlyingTypeGWI() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxNullableValueOfInlineClassWithNullableInlineClassUnderlyingTypeGWI.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("unboxNullableValueOfInlineClassWithNullableInlineClassUnderlyingTypeGWI2.kt") + public void testUnboxNullableValueOfInlineClassWithNullableInlineClassUnderlyingTypeGWI2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxNullableValueOfInlineClassWithNullableInlineClassUnderlyingTypeGWI2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("unboxNullableValueOfInlineClassWithNullablePrimitiveUnderlyingType.kt") + public void testUnboxNullableValueOfInlineClassWithNullablePrimitiveUnderlyingType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxNullableValueOfInlineClassWithNullablePrimitiveUnderlyingType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("unboxNullableValueOfInlineClassWithNullablePrimitiveUnderlyingTypeGWI.kt") + public void testUnboxNullableValueOfInlineClassWithNullablePrimitiveUnderlyingTypeGWI() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxNullableValueOfInlineClassWithNullablePrimitiveUnderlyingTypeGWI.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("unboxNullableValueOfInlineClassWithNullablePrimitiveUnderlyingTypeGWI2.kt") + public void testUnboxNullableValueOfInlineClassWithNullablePrimitiveUnderlyingTypeGWI2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxNullableValueOfInlineClassWithNullablePrimitiveUnderlyingTypeGWI2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("unboxNullableValueOfInlineClassWithNullablePrimitiveUnderlyingTypeGeneric.kt") + public void testUnboxNullableValueOfInlineClassWithNullablePrimitiveUnderlyingTypeGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxNullableValueOfInlineClassWithNullablePrimitiveUnderlyingTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("unboxNullableValueOfInlineClassWithPrimitiveUnderlyingType.kt") + public void testUnboxNullableValueOfInlineClassWithPrimitiveUnderlyingType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxNullableValueOfInlineClassWithPrimitiveUnderlyingType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("unboxNullableValueOfInlineClassWithPrimitiveUnderlyingTypeGeneric.kt") + public void testUnboxNullableValueOfInlineClassWithPrimitiveUnderlyingTypeGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxNullableValueOfInlineClassWithPrimitiveUnderlyingTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("unboxParameterOfSuspendLambdaBeforeInvoke.kt") + public void testUnboxParameterOfSuspendLambdaBeforeInvoke() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxParameterOfSuspendLambdaBeforeInvoke.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("unboxParameterOfSuspendLambdaBeforeInvokeGeneric.kt") + public void testUnboxParameterOfSuspendLambdaBeforeInvokeGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxParameterOfSuspendLambdaBeforeInvokeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("unboxReceiverOnCallingMethodFromInlineClass.kt") + public void testUnboxReceiverOnCallingMethodFromInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxReceiverOnCallingMethodFromInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("unboxReceiverOnCallingMethodFromInlineClassGeneric.kt") + public void testUnboxReceiverOnCallingMethodFromInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxReceiverOnCallingMethodFromInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("unboxResultParameterWhenCapturingToCrossinlineLambda.kt") + public void testUnboxResultParameterWhenCapturingToCrossinlineLambda() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxResultParameterWhenCapturingToCrossinlineLambda.kt"); + } + + @Test + @TestMetadata("unboxValueFromPlatformType.kt") + public void testUnboxValueFromPlatformType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxValueFromPlatformType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("unboxValueFromPlatformTypeGeneric.kt") + public void testUnboxValueFromPlatformTypeGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxValueFromPlatformTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("unboxValueOfAnyBeforeMethodInvocation.kt") + public void testUnboxValueOfAnyBeforeMethodInvocation() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxValueOfAnyBeforeMethodInvocation.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("unboxValueOfAnyBeforeMethodInvocationGeneric.kt") + public void testUnboxValueOfAnyBeforeMethodInvocationGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxValueOfAnyBeforeMethodInvocationGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("unboxValueOfAnyBeforeMethodInvocationGeneric2.kt") + public void testUnboxValueOfAnyBeforeMethodInvocationGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxValueOfAnyBeforeMethodInvocationGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("unboxValueOfNullableInlineClassUsingInlineFunction.kt") + public void testUnboxValueOfNullableInlineClassUsingInlineFunction() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxValueOfNullableInlineClassUsingInlineFunction.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("useInlineClassesInsideElvisOperator.kt") + public void testUseInlineClassesInsideElvisOperator() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/useInlineClassesInsideElvisOperator.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("useInlineClassesInsideElvisOperatorGeneric.kt") + public void testUseInlineClassesInsideElvisOperatorGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/useInlineClassesInsideElvisOperatorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("useInlineFunctionInsideInlineClass.kt") + public void testUseInlineFunctionInsideInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/useInlineFunctionInsideInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("useInlineFunctionInsideInlineClassGeneric.kt") + public void testUseInlineFunctionInsideInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/useInlineFunctionInsideInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("useThisInsideInlineClass.kt") + public void testUseThisInsideInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/useThisInsideInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("useThisInsideInlineClassGeneric.kt") + public void testUseThisInsideInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/useThisInsideInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("whenWithSubject.kt") + public void testWhenWithSubject() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/whenWithSubject.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("whenWithSubjectGeneric.kt") + public void testWhenWithSubjectGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/whenWithSubjectGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda") + @TestDataPath("$PROJECT_ROOT") + public class BoxReturnValueInLambda { + @Test + public void testAllFilesPresentInBoxReturnValueInLambda() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("boxAny.kt") + public void testBoxAny() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxAnyGeneric.kt") + public void testBoxAnyGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxFunLiteralAny.kt") + public void testBoxFunLiteralAny() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxFunLiteralAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxFunLiteralAnyGeneric.kt") + public void testBoxFunLiteralAnyGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxFunLiteralAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxInt.kt") + public void testBoxInt() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxInt.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxIntGeneric.kt") + public void testBoxIntGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxIntGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableAny.kt") + public void testBoxNullableAny() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableAnyGeneric.kt") + public void testBoxNullableAnyGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableAnyGeneric2.kt") + public void testBoxNullableAnyGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableAnyGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableAnyNull.kt") + public void testBoxNullableAnyNull() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableAnyNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableAnyNullGeneric.kt") + public void testBoxNullableAnyNullGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableAnyNullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableAnyNullGeneric2.kt") + public void testBoxNullableAnyNullGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableAnyNullGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableInt.kt") + public void testBoxNullableInt() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableInt.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableIntGeneric.kt") + public void testBoxNullableIntGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableIntGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableIntGeneric2.kt") + public void testBoxNullableIntGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableIntGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableIntNull.kt") + public void testBoxNullableIntNull() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableIntNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableIntNullGeneric.kt") + public void testBoxNullableIntNullGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableIntNullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableIntNullGeneric2.kt") + public void testBoxNullableIntNullGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableIntNullGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableString.kt") + public void testBoxNullableString() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableString.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableStringGeneric.kt") + public void testBoxNullableStringGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableStringGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableStringGeneric2.kt") + public void testBoxNullableStringGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableStringGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableStringNull.kt") + public void testBoxNullableStringNull() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableStringNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableStringNullGeneric.kt") + public void testBoxNullableStringNullGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableStringNullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxNullableStringNullGeneric2.kt") + public void testBoxNullableStringNullGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxNullableStringNullGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxString.kt") + public void testBoxString() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxString.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxStringGeneric.kt") + public void testBoxStringGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/boxStringGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27586_1.kt") + public void testKt27586_1() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/kt27586_1.kt"); + } + + @Test + @TestMetadata("kt27586_2.kt") + public void testKt27586_2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueInLambda/kt27586_2.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride") + @TestDataPath("$PROJECT_ROOT") + public class BoxReturnValueOnOverride { + @Test + public void testAllFilesPresentInBoxReturnValueOnOverride() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("boxReturnValueInDefaultMethod.kt") + public void testBoxReturnValueInDefaultMethod() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/boxReturnValueInDefaultMethod.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boxReturnValueInDefaultMethodGenericInt.kt") + public void testBoxReturnValueInDefaultMethodGenericInt() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/boxReturnValueInDefaultMethodGenericInt.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("covariantOverrideChainErasedToAny.kt") + public void testCovariantOverrideChainErasedToAny() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("covariantOverrideChainErasedToAnyGeneric.kt") + public void testCovariantOverrideChainErasedToAnyGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("covariantOverrideChainErasedToNullableAny.kt") + public void testCovariantOverrideChainErasedToNullableAny() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToNullableAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("covariantOverrideChainErasedToNullableAnyGeneric.kt") + public void testCovariantOverrideChainErasedToNullableAnyGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToNullableAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("covariantOverrideChainErasedToNullableAnyGeneric2.kt") + public void testCovariantOverrideChainErasedToNullableAnyGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideChainErasedToNullableAnyGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("covariantOverrideErasedToAny.kt") + public void testCovariantOverrideErasedToAny() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("covariantOverrideErasedToAnyGeneric.kt") + public void testCovariantOverrideErasedToAnyGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("covariantOverrideErasedToInterface.kt") + public void testCovariantOverrideErasedToInterface() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToInterface.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("covariantOverrideErasedToInterfaceGeneric.kt") + public void testCovariantOverrideErasedToInterfaceGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToInterfaceGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("covariantOverrideErasedToPrimitive.kt") + public void testCovariantOverrideErasedToPrimitive() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToPrimitive.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("covariantOverrideErasedToPrimitiveGeneric.kt") + public void testCovariantOverrideErasedToPrimitiveGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideErasedToPrimitiveGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("covariantOverrideListVsMutableList.kt") + public void testCovariantOverrideListVsMutableList() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideListVsMutableList.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("covariantOverrideListVsMutableListGeneric.kt") + public void testCovariantOverrideListVsMutableListGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideListVsMutableListGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("covariantOverrideUnrelatedInterfaces.kt") + public void testCovariantOverrideUnrelatedInterfaces() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideUnrelatedInterfaces.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("covariantOverrideUnrelatedInterfacesGeneric.kt") + public void testCovariantOverrideUnrelatedInterfacesGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/covariantOverrideUnrelatedInterfacesGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("genericOverride.kt") + public void testGenericOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverride.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("genericOverrideGeneric.kt") + public void testGenericOverrideGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverrideGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("genericOverrideSpecialized.kt") + public void testGenericOverrideSpecialized() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverrideSpecialized.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("genericOverrideSpecializedGeneric.kt") + public void testGenericOverrideSpecializedGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/genericOverrideSpecializedGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassInOverriddenReturnTypes.kt") + public void testInlineClassInOverriddenReturnTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/inlineClassInOverriddenReturnTypes.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassInOverriddenReturnTypesGeneric.kt") + public void testInlineClassInOverriddenReturnTypesGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/inlineClassInOverriddenReturnTypesGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt28483.kt") + public void testKt28483() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt28483.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt28483Generic.kt") + public void testKt28483Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt28483Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt28483Generic2.kt") + public void testKt28483Generic2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt28483Generic2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt31585.kt") + public void testKt31585() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt31585.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt31585Generic.kt") + public void testKt31585Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt31585Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt35234.kt") + public void testKt35234() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt35234.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt35234Generic.kt") + public void testKt35234Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt35234Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt35234a.kt") + public void testKt35234a() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/kt35234a.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overrideGenericWithInlineClass.kt") + public void testOverrideGenericWithInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overrideGenericWithInlineClassGeneric.kt") + public void testOverrideGenericWithInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullAny.kt") + public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullAny() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullAnyGeneric.kt") + public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullAnyGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAny.kt") + public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAny() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyG.kt") + public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyG() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyG.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyG2.kt") + public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyG2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyG2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNG.kt") + public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNG() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNG.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNG2.kt") + public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNG2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNG2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNull.kt") + public void testOverrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNull() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideGenericWithNullableInlineClassUpperBoundWithNonNullNullableAnyNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overrideNullableInlineClassWithNonNullAny.kt") + public void testOverrideNullableInlineClassWithNonNullAny() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overrideNullableInlineClassWithNonNullAnyGeneric.kt") + public void testOverrideNullableInlineClassWithNonNullAnyGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overrideNullableInlineClassWithNonNullNullableAny.kt") + public void testOverrideNullableInlineClassWithNonNullNullableAny() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overrideNullableInlineClassWithNonNullNullableAnyGeneric.kt") + public void testOverrideNullableInlineClassWithNonNullNullableAnyGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overrideNullableInlineClassWithNonNullNullableAnyGeneric2.kt") + public void testOverrideNullableInlineClassWithNonNullNullableAnyGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAnyGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overrideNullableInlineClassWithNonNullNullableAnyNull.kt") + public void testOverrideNullableInlineClassWithNonNullNullableAnyNull() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAnyNull.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overrideNullableInlineClassWithNonNullNullableAnyNullGeneric.kt") + public void testOverrideNullableInlineClassWithNonNullNullableAnyNullGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAnyNullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overrideNullableInlineClassWithNonNullNullableAnyNullGeneric2.kt") + public void testOverrideNullableInlineClassWithNonNullNullableAnyNullGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/overrideNullableInlineClassWithNonNullNullableAnyNullGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("relatedReturnTypes1a.kt") + public void testRelatedReturnTypes1a() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1a.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("relatedReturnTypes1aGeneric.kt") + public void testRelatedReturnTypes1aGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1aGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("relatedReturnTypes1b.kt") + public void testRelatedReturnTypes1b() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1b.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("relatedReturnTypes1bGeneric.kt") + public void testRelatedReturnTypes1bGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes1bGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("relatedReturnTypes2a.kt") + public void testRelatedReturnTypes2a() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2a.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("relatedReturnTypes2aGeneric.kt") + public void testRelatedReturnTypes2aGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2aGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("relatedReturnTypes2b.kt") + public void testRelatedReturnTypes2b() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2b.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("relatedReturnTypes2bGeneric.kt") + public void testRelatedReturnTypes2bGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/relatedReturnTypes2bGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("uncastInlineClassToAnyAndBack.kt") + public void testUncastInlineClassToAnyAndBack() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/uncastInlineClassToAnyAndBack.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("uncastInlineClassToAnyAndBackGeneric.kt") + public void testUncastInlineClassToAnyAndBackGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/uncastInlineClassToAnyAndBackGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("unrelatedGenerics.kt") + public void testUnrelatedGenerics() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/unrelatedGenerics.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("unrelatedGenericsGeneric.kt") + public void testUnrelatedGenericsGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/boxReturnValueOnOverride/unrelatedGenericsGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/callableReferences") + @TestDataPath("$PROJECT_ROOT") + public class CallableReferences { + @Test + public void testAllFilesPresentInCallableReferences() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/callableReferences"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("boundInlineClassExtensionFun.kt") + public void testBoundInlineClassExtensionFun() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassExtensionFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boundInlineClassExtensionFunGeneric.kt") + public void testBoundInlineClassExtensionFunGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassExtensionFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boundInlineClassExtensionVal.kt") + public void testBoundInlineClassExtensionVal() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassExtensionVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boundInlineClassExtensionValGeneric.kt") + public void testBoundInlineClassExtensionValGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassExtensionValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boundInlineClassMemberFun.kt") + public void testBoundInlineClassMemberFun() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassMemberFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boundInlineClassMemberFunGeneric.kt") + public void testBoundInlineClassMemberFunGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassMemberFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boundInlineClassMemberVal.kt") + public void testBoundInlineClassMemberVal() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassMemberVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boundInlineClassMemberValGeneric.kt") + public void testBoundInlineClassMemberValGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassMemberValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boundInlineClassPrimaryVal.kt") + public void testBoundInlineClassPrimaryVal() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassPrimaryVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("boundInlineClassPrimaryValGeneric.kt") + public void testBoundInlineClassPrimaryValGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/boundInlineClassPrimaryValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("constructorWithInlineClassParameters.kt") + public void testConstructorWithInlineClassParameters() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/constructorWithInlineClassParameters.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("constructorWithInlineClassParametersGeneric.kt") + public void testConstructorWithInlineClassParametersGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/constructorWithInlineClassParametersGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalsHashCodeToString.kt") + public void testEqualsHashCodeToString() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/equalsHashCodeToString.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("equalsHashCodeToStringGeneric.kt") + public void testEqualsHashCodeToStringGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/equalsHashCodeToStringGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("funWithInlineClassParameters.kt") + public void testFunWithInlineClassParameters() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/funWithInlineClassParameters.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("funWithInlineClassParametersGeneric.kt") + public void testFunWithInlineClassParametersGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/funWithInlineClassParametersGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassExtensionFun.kt") + public void testInlineClassExtensionFun() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassExtensionFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassExtensionFunGeneric.kt") + public void testInlineClassExtensionFunGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassExtensionFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassExtensionVal.kt") + public void testInlineClassExtensionVal() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassExtensionVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassExtensionValGeneric.kt") + public void testInlineClassExtensionValGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassExtensionValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassInternalPrimaryVal.kt") + public void testInlineClassInternalPrimaryVal() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassInternalPrimaryVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassInternalPrimaryValGeneric.kt") + public void testInlineClassInternalPrimaryValGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassInternalPrimaryValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassMemberFun.kt") + public void testInlineClassMemberFun() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassMemberFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassMemberFunGeneric.kt") + public void testInlineClassMemberFunGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassMemberFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassMemberVal.kt") + public void testInlineClassMemberVal() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassMemberVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassMemberValGeneric.kt") + public void testInlineClassMemberValGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassMemberValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassPrimaryConstructor.kt") + public void testInlineClassPrimaryConstructor() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrimaryConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassPrimaryConstructorGeneric.kt") + public void testInlineClassPrimaryConstructorGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrimaryConstructorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassPrimaryVal.kt") + public void testInlineClassPrimaryVal() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrimaryVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassPrimaryValGeneric.kt") + public void testInlineClassPrimaryValGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrimaryValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassPrivatePrimaryVal.kt") + public void testInlineClassPrivatePrimaryVal() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrivatePrimaryVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassPrivatePrimaryValGeneric.kt") + public void testInlineClassPrivatePrimaryValGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassPrivatePrimaryValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassTypeBoundMemberVar.kt") + public void testInlineClassTypeBoundMemberVar() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeBoundMemberVar.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassTypeBoundMemberVarGeneric.kt") + public void testInlineClassTypeBoundMemberVarGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeBoundMemberVarGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassTypeMemberVar.kt") + public void testInlineClassTypeMemberVar() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeMemberVar.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassTypeMemberVarGeneric.kt") + public void testInlineClassTypeMemberVarGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeMemberVarGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassTypeTopLevelVar.kt") + public void testInlineClassTypeTopLevelVar() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeTopLevelVar.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassTypeTopLevelVarGeneric.kt") + public void testInlineClassTypeTopLevelVarGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/inlineClassTypeTopLevelVarGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt37986.kt") + public void testKt37986() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/kt37986.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt37986Generic.kt") + public void testKt37986Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/kt37986Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/callableReferences/let") + @TestDataPath("$PROJECT_ROOT") + public class Let { + @Test + public void testAllFilesPresentInLet() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/callableReferences/let"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("any.kt") + public void testAny() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/any.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("anyGeneric.kt") + public void testAnyGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/anyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("anyN.kt") + public void testAnyN() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/anyN.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("anyNGeneric.kt") + public void testAnyNGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/anyNGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("anyNGeneric2.kt") + public void testAnyNGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/anyNGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("int.kt") + public void testInt() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/int.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("intGeneric.kt") + public void testIntGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/intGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("intN.kt") + public void testIntN() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/intN.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("intNGeneric.kt") + public void testIntNGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/intNGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("intNGeneric2.kt") + public void testIntNGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/intNGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("null.kt") + public void testNull() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/null.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("nullGeneric.kt") + public void testNullGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/nullGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("result.kt") + public void testResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/result.kt"); + } + + @Test + @TestMetadata("string.kt") + public void testString() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/string.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("stringGeneric.kt") + public void testStringGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/stringGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("stringN.kt") + public void testStringN() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/stringN.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("stringNGeneric.kt") + public void testStringNGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/stringNGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("stringNGeneric2.kt") + public void testStringNGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/callableReferences/let/stringNGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors") + @TestDataPath("$PROJECT_ROOT") + public class ContextsAndAccessors { + @Test + @TestMetadata("accessPrivateInlineClassCompanionMethod.kt") + public void testAccessPrivateInlineClassCompanionMethod() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassCompanionMethod.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("accessPrivateInlineClassCompanionMethod2.kt") + public void testAccessPrivateInlineClassCompanionMethod2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassCompanionMethod2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("accessPrivateInlineClassCompanionMethod2Generic.kt") + public void testAccessPrivateInlineClassCompanionMethod2Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassCompanionMethod2Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("accessPrivateInlineClassCompanionMethodGeneric.kt") + public void testAccessPrivateInlineClassCompanionMethodGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassCompanionMethodGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("accessPrivateInlineClassConstructorFromCompanion.kt") + public void testAccessPrivateInlineClassConstructorFromCompanion() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassConstructorFromCompanion.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("accessPrivateInlineClassConstructorFromCompanionGeneric.kt") + public void testAccessPrivateInlineClassConstructorFromCompanionGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassConstructorFromCompanionGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("accessPrivateInlineClassConstructorFromLambda.kt") + public void testAccessPrivateInlineClassConstructorFromLambda() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassConstructorFromLambda.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("accessPrivateInlineClassConstructorFromLambdaGeneric.kt") + public void testAccessPrivateInlineClassConstructorFromLambdaGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassConstructorFromLambdaGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("accessPrivateInlineClassMethodFromCompanion.kt") + public void testAccessPrivateInlineClassMethodFromCompanion() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromCompanion.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("accessPrivateInlineClassMethodFromCompanion2.kt") + public void testAccessPrivateInlineClassMethodFromCompanion2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromCompanion2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("accessPrivateInlineClassMethodFromCompanion2Generic.kt") + public void testAccessPrivateInlineClassMethodFromCompanion2Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromCompanion2Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("accessPrivateInlineClassMethodFromCompanionGeneric.kt") + public void testAccessPrivateInlineClassMethodFromCompanionGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromCompanionGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("accessPrivateInlineClassMethodFromInlineLambda.kt") + public void testAccessPrivateInlineClassMethodFromInlineLambda() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromInlineLambda.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("accessPrivateInlineClassMethodFromInlineLambda2.kt") + public void testAccessPrivateInlineClassMethodFromInlineLambda2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromInlineLambda2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("accessPrivateInlineClassMethodFromInlineLambda2Generic.kt") + public void testAccessPrivateInlineClassMethodFromInlineLambda2Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromInlineLambda2Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("accessPrivateInlineClassMethodFromInlineLambdaGeneric.kt") + public void testAccessPrivateInlineClassMethodFromInlineLambdaGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromInlineLambdaGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("accessPrivateInlineClassMethodFromLambda.kt") + public void testAccessPrivateInlineClassMethodFromLambda() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromLambda.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("accessPrivateInlineClassMethodFromLambda2.kt") + public void testAccessPrivateInlineClassMethodFromLambda2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromLambda2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("accessPrivateInlineClassMethodFromLambda2Generic.kt") + public void testAccessPrivateInlineClassMethodFromLambda2Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromLambda2Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("accessPrivateInlineClassMethodFromLambdaGeneric.kt") + public void testAccessPrivateInlineClassMethodFromLambdaGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/accessPrivateInlineClassMethodFromLambdaGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + public void testAllFilesPresentInContextsAndAccessors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("captureInlineClassInstanceInLambda.kt") + public void testCaptureInlineClassInstanceInLambda() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInLambda.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("captureInlineClassInstanceInLambda2.kt") + public void testCaptureInlineClassInstanceInLambda2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInLambda2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("captureInlineClassInstanceInLambda2Generic.kt") + public void testCaptureInlineClassInstanceInLambda2Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInLambda2Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("captureInlineClassInstanceInLambdaGeneric.kt") + public void testCaptureInlineClassInstanceInLambdaGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInLambdaGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("captureInlineClassInstanceInObject.kt") + public void testCaptureInlineClassInstanceInObject() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInObject.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("captureInlineClassInstanceInObjectGeneric.kt") + public void testCaptureInlineClassInstanceInObjectGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/captureInlineClassInstanceInObjectGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineLambdaInInlineClassFun.kt") + public void testInlineLambdaInInlineClassFun() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/inlineLambdaInInlineClassFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineLambdaInInlineClassFunGeneric.kt") + public void testInlineLambdaInInlineClassFunGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/inlineLambdaInInlineClassFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt26858.kt") + public void testKt26858() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt26858.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt26858Generic.kt") + public void testKt26858Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt26858Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27513.kt") + public void testKt27513() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt27513.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27513Generic.kt") + public void testKt27513Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt27513Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt30780.kt") + public void testKt30780() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt30780.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt30780Generic.kt") + public void testKt30780Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/kt30780Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("lambdaInInlineClassFun.kt") + public void testLambdaInInlineClassFun() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/lambdaInInlineClassFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("lambdaInInlineClassFunGeneric.kt") + public void testLambdaInInlineClassFunGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/lambdaInInlineClassFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("objectInInlineClassFun.kt") + public void testObjectInInlineClassFun() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/objectInInlineClassFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("objectInInlineClassFunGeneric.kt") + public void testObjectInInlineClassFunGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/objectInInlineClassFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("toPrivateCompanionFun.kt") + public void testToPrivateCompanionFun() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/toPrivateCompanionFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("toPrivateCompanionFunGeneric.kt") + public void testToPrivateCompanionFunGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/toPrivateCompanionFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("toPrivateCompanionVal.kt") + public void testToPrivateCompanionVal() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/toPrivateCompanionVal.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("toPrivateCompanionValGeneric.kt") + public void testToPrivateCompanionValGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/contextsAndAccessors/toPrivateCompanionValGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/defaultParameterValues") + @TestDataPath("$PROJECT_ROOT") + public class DefaultParameterValues { + @Test + public void testAllFilesPresentInDefaultParameterValues() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("defaultConstructorParameterValuesOfInlineClassType.kt") + public void testDefaultConstructorParameterValuesOfInlineClassType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultConstructorParameterValuesOfInlineClassType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("defaultConstructorParameterValuesOfInlineClassTypeGeneric.kt") + public void testDefaultConstructorParameterValuesOfInlineClassTypeGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultConstructorParameterValuesOfInlineClassTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("defaultInterfaceFunParameterValuesOfInlineClassType.kt") + public void testDefaultInterfaceFunParameterValuesOfInlineClassType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultInterfaceFunParameterValuesOfInlineClassType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("defaultInterfaceFunParameterValuesOfInlineClassTypeGeneric.kt") + public void testDefaultInterfaceFunParameterValuesOfInlineClassTypeGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultInterfaceFunParameterValuesOfInlineClassTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("defaultParameterValuesOfInlineClassType.kt") + public void testDefaultParameterValuesOfInlineClassType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultParameterValuesOfInlineClassType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("defaultParameterValuesOfInlineClassTypeBoxing.kt") + public void testDefaultParameterValuesOfInlineClassTypeBoxing() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultParameterValuesOfInlineClassTypeBoxing.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("defaultParameterValuesOfInlineClassTypeBoxingGeneric.kt") + public void testDefaultParameterValuesOfInlineClassTypeBoxingGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultParameterValuesOfInlineClassTypeBoxingGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("defaultParameterValuesOfInlineClassTypeGeneric.kt") + public void testDefaultParameterValuesOfInlineClassTypeGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultParameterValuesOfInlineClassTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("defaultValueOfInlineClassTypeInInlineFun.kt") + public void testDefaultValueOfInlineClassTypeInInlineFun() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultValueOfInlineClassTypeInInlineFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("defaultValueOfInlineClassTypeInInlineFunGeneric.kt") + public void testDefaultValueOfInlineClassTypeInInlineFunGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultValueOfInlineClassTypeInInlineFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("defaultValueOfInlineClassTypeInInlineFunInInlineClass.kt") + public void testDefaultValueOfInlineClassTypeInInlineFunInInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultValueOfInlineClassTypeInInlineFunInInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("defaultValueOfInlineClassTypeInInlineFunInInlineClassGeneric.kt") + public void testDefaultValueOfInlineClassTypeInInlineFunInInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultValueOfInlineClassTypeInInlineFunInInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassFun.kt") + public void testInlineClassFun() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/inlineClassFun.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassFunGeneric.kt") + public void testInlineClassFunGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/inlineClassFunGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassPrimaryConstructor.kt") + public void testInlineClassPrimaryConstructor() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/inlineClassPrimaryConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassPrimaryConstructorGeneric.kt") + public void testInlineClassPrimaryConstructorGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/inlineClassPrimaryConstructorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassPrimaryConstructorWithInlineClassValue.kt") + public void testInlineClassPrimaryConstructorWithInlineClassValue() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/inlineClassPrimaryConstructorWithInlineClassValue.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassPrimaryConstructorWithInlineClassValueGeneric.kt") + public void testInlineClassPrimaryConstructorWithInlineClassValueGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/inlineClassPrimaryConstructorWithInlineClassValueGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassSecondaryConstructor.kt") + public void testInlineClassSecondaryConstructor() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/inlineClassSecondaryConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineClassSecondaryConstructorGeneric.kt") + public void testInlineClassSecondaryConstructorGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/inlineClassSecondaryConstructorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt26554.kt") + public void testKt26554() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/kt26554.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27416.kt") + public void testKt27416() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/kt27416.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27416Generic.kt") + public void testKt27416Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/kt27416Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultWithDefaultParameter") + @TestDataPath("$PROJECT_ROOT") + public class DefaultWithDefaultParameter { + @Test + public void testAllFilesPresentInDefaultWithDefaultParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/defaultWithDefaultParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter") + @TestDataPath("$PROJECT_ROOT") + public class OverrideFunctionWithDefaultParameter { + @Test + public void testAllFilesPresentInOverrideFunctionWithDefaultParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/defaultParameterValues/overrideFunctionWithDefaultParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/delegationByUnderlyingType") + @TestDataPath("$PROJECT_ROOT") + public class DelegationByUnderlyingType { + @Test + public void testAllFilesPresentInDelegationByUnderlyingType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/delegationByUnderlyingType"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("default.kt") + public void testDefault() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/delegationByUnderlyingType/default.kt"); + } + + @Test + @TestMetadata("defaultArgument.kt") + public void testDefaultArgument() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/delegationByUnderlyingType/defaultArgument.kt"); + } + + @Test + @TestMetadata("defaultArgumentGeneric.kt") + public void testDefaultArgumentGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/delegationByUnderlyingType/defaultArgumentGeneric.kt"); + } + + @Test + @TestMetadata("defaultGeneric.kt") + public void testDefaultGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/delegationByUnderlyingType/defaultGeneric.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/delegationByUnderlyingType/simple.kt"); + } + + @Test + @TestMetadata("simpleGeneric.kt") + public void testSimpleGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/delegationByUnderlyingType/simpleGeneric.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/funInterface") + @TestDataPath("$PROJECT_ROOT") + public class FunInterface { + @Test + public void testAllFilesPresentInFunInterface() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/funInterface"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("argumentIC.kt") + public void testArgumentIC() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/argumentIC.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("argumentICGeneric.kt") + public void testArgumentICGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/argumentICGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("argumentICGeneric2.kt") + public void testArgumentICGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/argumentICGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("argumentResult.kt") + public void testArgumentResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/argumentResult.kt"); + } + + @Test + @TestMetadata("kt51121.kt") + public void testKt51121() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/kt51121.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt51121_2.kt") + public void testKt51121_2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/kt51121_2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("mangledSamWrappers.kt") + public void testMangledSamWrappers() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/mangledSamWrappers.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("mangledSamWrappersGeneric.kt") + public void testMangledSamWrappersGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/mangledSamWrappersGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("returnIC.kt") + public void testReturnIC() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/returnIC.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("returnICGeneric.kt") + public void testReturnICGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/returnICGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("returnICGeneric2.kt") + public void testReturnICGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/returnICGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("returnResult.kt") + public void testReturnResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/funInterface/returnResult.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/functionNameMangling") + @TestDataPath("$PROJECT_ROOT") + public class FunctionNameMangling { + @Test + public void testAllFilesPresentInFunctionNameMangling() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/functionNameMangling"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("anonymousObjectInFunctionWithMangledName.kt") + public void testAnonymousObjectInFunctionWithMangledName() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/anonymousObjectInFunctionWithMangledName.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("anonymousObjectInFunctionWithMangledNameGeneric.kt") + public void testAnonymousObjectInFunctionWithMangledNameGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/anonymousObjectInFunctionWithMangledNameGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("extensionFunctionsDoNotClash.kt") + public void testExtensionFunctionsDoNotClash() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/extensionFunctionsDoNotClash.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("extensionFunctionsDoNotClashGeneric.kt") + public void testExtensionFunctionsDoNotClashGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/extensionFunctionsDoNotClashGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("functionsWithDifferentNullabilityDoNotClash.kt") + public void testFunctionsWithDifferentNullabilityDoNotClash() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/functionsWithDifferentNullabilityDoNotClash.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("functionsWithDifferentNullabilityDoNotClashGeneric.kt") + public void testFunctionsWithDifferentNullabilityDoNotClashGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/functionsWithDifferentNullabilityDoNotClashGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("genericFunctionsDoNotClash.kt") + public void testGenericFunctionsDoNotClash() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/genericFunctionsDoNotClash.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("genericFunctionsDoNotClashGeneric.kt") + public void testGenericFunctionsDoNotClashGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/genericFunctionsDoNotClashGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("localClassInFunctionWithMangledName.kt") + public void testLocalClassInFunctionWithMangledName() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/localClassInFunctionWithMangledName.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("localClassInFunctionWithMangledNameGeneric.kt") + public void testLocalClassInFunctionWithMangledNameGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/localClassInFunctionWithMangledNameGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("mangledFunctionsCanBeOverridden.kt") + public void testMangledFunctionsCanBeOverridden() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/mangledFunctionsCanBeOverridden.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("mangledFunctionsCanBeOverriddenGeneric.kt") + public void testMangledFunctionsCanBeOverriddenGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/mangledFunctionsCanBeOverriddenGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("mangledFunctionsDoNotClash.kt") + public void testMangledFunctionsDoNotClash() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/mangledFunctionsDoNotClash.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("mangledFunctionsDoNotClashGeneric.kt") + public void testMangledFunctionsDoNotClashGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/mangledFunctionsDoNotClashGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("mangledFunctionsPresentInStackTrace.kt") + public void testMangledFunctionsPresentInStackTrace() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/mangledFunctionsPresentInStackTrace.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("mangledFunctionsPresentInStackTraceGeneric.kt") + public void testMangledFunctionsPresentInStackTraceGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/mangledFunctionsPresentInStackTraceGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("mixedSignatureFunctionsDoNotClash.kt") + public void testMixedSignatureFunctionsDoNotClash() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/mixedSignatureFunctionsDoNotClash.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("mixedSignatureFunctionsDoNotClashGeneric.kt") + public void testMixedSignatureFunctionsDoNotClashGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/mixedSignatureFunctionsDoNotClashGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overridingMethodInGenericClass.kt") + public void testOverridingMethodInGenericClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/overridingMethodInGenericClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overridingMethodInGenericClass2.kt") + public void testOverridingMethodInGenericClass2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/overridingMethodInGenericClass2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overridingMethodInGenericClass2Generic.kt") + public void testOverridingMethodInGenericClass2Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/overridingMethodInGenericClass2Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overridingMethodInGenericClassGeneric.kt") + public void testOverridingMethodInGenericClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/overridingMethodInGenericClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("propertySetterWithInlineClassTypeArgument.kt") + public void testPropertySetterWithInlineClassTypeArgument() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/propertySetterWithInlineClassTypeArgument.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("propertySetterWithInlineClassTypeArgumentGeneric.kt") + public void testPropertySetterWithInlineClassTypeArgumentGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/propertySetterWithInlineClassTypeArgumentGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("reflectionForFunctionWithMangledName.kt") + public void testReflectionForFunctionWithMangledName() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/reflectionForFunctionWithMangledName.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("reflectionForFunctionWithMangledNameGeneric.kt") + public void testReflectionForFunctionWithMangledNameGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/reflectionForFunctionWithMangledNameGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("reflectionForPropertyOfInlineClassType.kt") + public void testReflectionForPropertyOfInlineClassType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/reflectionForPropertyOfInlineClassType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("reflectionForPropertyOfInlineClassTypeGeneric.kt") + public void testReflectionForPropertyOfInlineClassTypeGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/reflectionForPropertyOfInlineClassTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("syntheticAccessorForFunctionWithMangledName.kt") + public void testSyntheticAccessorForFunctionWithMangledName() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/syntheticAccessorForFunctionWithMangledName.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("syntheticAccessorForFunctionWithMangledNameGeneric.kt") + public void testSyntheticAccessorForFunctionWithMangledNameGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/syntheticAccessorForFunctionWithMangledNameGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("syntheticAccessorsForPropertyOfInlineClassType.kt") + public void testSyntheticAccessorsForPropertyOfInlineClassType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/syntheticAccessorsForPropertyOfInlineClassType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("syntheticAccessorsForPropertyOfInlineClassTypeGeneric.kt") + public void testSyntheticAccessorsForPropertyOfInlineClassTypeGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/functionNameMangling/syntheticAccessorsForPropertyOfInlineClassTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/genericUnderlyingValue") + @TestDataPath("$PROJECT_ROOT") + public class GenericUnderlyingValue { + @Test + public void testAllFilesPresentInGenericUnderlyingValue() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/genericUnderlyingValue"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("array.kt") + public void testArray() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/genericUnderlyingValue/array.kt"); + } + + @Test + @TestMetadata("arrayIC.kt") + public void testArrayIC() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/genericUnderlyingValue/arrayIC.kt"); + } + + @Test + @TestMetadata("primitive.kt") + public void testPrimitive() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/genericUnderlyingValue/primitive.kt"); + } + + @Test + @TestMetadata("recursive.kt") + public void testRecursive() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/genericUnderlyingValue/recursive.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/genericUnderlyingValue/simple.kt"); + } + + @Test + @TestMetadata("simple2.kt") + public void testSimple2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/genericUnderlyingValue/simple2.kt"); + } + + @Test + @TestMetadata("upperBound.kt") + public void testUpperBound() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/genericUnderlyingValue/upperBound.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/hiddenConstructor") + @TestDataPath("$PROJECT_ROOT") + public class HiddenConstructor { + @Test + public void testAllFilesPresentInHiddenConstructor() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/hiddenConstructor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("constructorReferencedFromOtherFile1.kt") + public void testConstructorReferencedFromOtherFile1() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/constructorReferencedFromOtherFile1.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("constructorReferencedFromOtherFile1Generic.kt") + public void testConstructorReferencedFromOtherFile1Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/constructorReferencedFromOtherFile1Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("constructorReferencedFromOtherFile2.kt") + public void testConstructorReferencedFromOtherFile2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/constructorReferencedFromOtherFile2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("constructorReferencedFromOtherFile2Generic.kt") + public void testConstructorReferencedFromOtherFile2Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/constructorReferencedFromOtherFile2Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("constructorWithDefaultParameters.kt") + public void testConstructorWithDefaultParameters() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/constructorWithDefaultParameters.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("constructorWithDefaultParametersGeneric.kt") + public void testConstructorWithDefaultParametersGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/constructorWithDefaultParametersGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("delegatingSuperConstructorCall.kt") + public void testDelegatingSuperConstructorCall() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/delegatingSuperConstructorCall.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("delegatingSuperConstructorCallGeneric.kt") + public void testDelegatingSuperConstructorCallGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/delegatingSuperConstructorCallGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("delegatingSuperConstructorCallInSecondaryConstructor.kt") + public void testDelegatingSuperConstructorCallInSecondaryConstructor() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/delegatingSuperConstructorCallInSecondaryConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("delegatingSuperConstructorCallInSecondaryConstructorGeneric.kt") + public void testDelegatingSuperConstructorCallInSecondaryConstructorGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/delegatingSuperConstructorCallInSecondaryConstructorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("delegatingThisConstructorCall.kt") + public void testDelegatingThisConstructorCall() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/delegatingThisConstructorCall.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("delegatingThisConstructorCallGeneric.kt") + public void testDelegatingThisConstructorCallGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/delegatingThisConstructorCallGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("enumClassConstructor.kt") + public void testEnumClassConstructor() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/enumClassConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("enumClassConstructorGeneric.kt") + public void testEnumClassConstructorGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/enumClassConstructorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("innerClassConstructor.kt") + public void testInnerClassConstructor() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/innerClassConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("innerClassConstructorGeneric.kt") + public void testInnerClassConstructorGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/innerClassConstructorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt28855.kt") + public void testKt28855() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/kt28855.kt"); + } + + @Test + @TestMetadata("primaryConstructor.kt") + public void testPrimaryConstructor() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/primaryConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("primaryConstructorGeneric.kt") + public void testPrimaryConstructorGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/primaryConstructorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("privateConstructor.kt") + public void testPrivateConstructor() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/privateConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("privateConstructorGeneric.kt") + public void testPrivateConstructorGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/privateConstructorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("sealedClassConstructor.kt") + public void testSealedClassConstructor() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/sealedClassConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("sealedClassConstructorGeneric.kt") + public void testSealedClassConstructorGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/sealedClassConstructorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("secondaryConstructor.kt") + public void testSecondaryConstructor() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/secondaryConstructor.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("secondaryConstructorGeneric.kt") + public void testSecondaryConstructorGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/hiddenConstructor/secondaryConstructorGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/inlineClassCollection") + @TestDataPath("$PROJECT_ROOT") + public class InlineClassCollection { + @Test + public void testAllFilesPresentInInlineClassCollection() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/inlineClassCollection"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("inlineCollectionOfInlineClass.kt") + public void testInlineCollectionOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineCollectionOfInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineCollectionOfInlineClassGeneric.kt") + public void testInlineCollectionOfInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineCollectionOfInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineListOfInlineClass.kt") + public void testInlineListOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineListOfInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineListOfInlineClassGeneric.kt") + public void testInlineListOfInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineListOfInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineMapOfInlineClass.kt") + public void testInlineMapOfInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineMapOfInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineMapOfInlineClassGeneric.kt") + public void testInlineMapOfInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineMapOfInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("inlineMutableCollectionBulkAdd.kt") + public void testInlineMutableCollectionBulkAdd() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/inlineClassCollection/inlineMutableCollectionBulkAdd.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/interfaceDelegation") + @TestDataPath("$PROJECT_ROOT") + public class InterfaceDelegation { + @Test + public void testAllFilesPresentInInterfaceDelegation() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceDelegation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("interfaceImplementationByDelegation.kt") + public void testInterfaceImplementationByDelegation() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/interfaceImplementationByDelegation.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("interfaceImplementationByDelegationGeneric.kt") + public void testInterfaceImplementationByDelegationGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/interfaceImplementationByDelegationGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt38337.kt") + public void testKt38337() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/kt38337.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt38337Generic.kt") + public void testKt38337Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/kt38337Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("memberExtValDelegationWithInlineClassParameterTypes.kt") + public void testMemberExtValDelegationWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtValDelegationWithInlineClassParameterTypes.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("memberExtValDelegationWithInlineClassParameterTypesGeneric.kt") + public void testMemberExtValDelegationWithInlineClassParameterTypesGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtValDelegationWithInlineClassParameterTypesGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("memberExtVarDelegationWithInlineClassParameterTypes.kt") + public void testMemberExtVarDelegationWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberExtVarDelegationWithInlineClassParameterTypes.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("memberFunDelegatedToInlineClassInt.kt") + public void testMemberFunDelegatedToInlineClassInt() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassInt.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("memberFunDelegatedToInlineClassIntGeneric.kt") + public void testMemberFunDelegatedToInlineClassIntGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassIntGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("memberFunDelegatedToInlineClassLong.kt") + public void testMemberFunDelegatedToInlineClassLong() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassLong.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("memberFunDelegatedToInlineClassLongGeneric.kt") + public void testMemberFunDelegatedToInlineClassLongGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegatedToInlineClassLongGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("memberFunDelegationToInlineClassWithInlineClassParameterTypes.kt") + public void testMemberFunDelegationToInlineClassWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationToInlineClassWithInlineClassParameterTypes.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("memberFunDelegationToInlineClassWithInlineClassParameterTypesGeneric.kt") + public void testMemberFunDelegationToInlineClassWithInlineClassParameterTypesGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationToInlineClassWithInlineClassParameterTypesGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("memberFunDelegationWithInlineClassParameterTypes.kt") + public void testMemberFunDelegationWithInlineClassParameterTypes() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationWithInlineClassParameterTypes.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("memberFunDelegationWithInlineClassParameterTypesGeneric.kt") + public void testMemberFunDelegationWithInlineClassParameterTypesGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceDelegation/memberFunDelegationWithInlineClassParameterTypesGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls") + @TestDataPath("$PROJECT_ROOT") + public class InterfaceMethodCalls { + @Test + public void testAllFilesPresentInInterfaceMethodCalls() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("complexGenericMethodWithInlineClassOverride.kt") + public void testComplexGenericMethodWithInlineClassOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/complexGenericMethodWithInlineClassOverride.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("complexGenericMethodWithInlineClassOverride2.kt") + public void testComplexGenericMethodWithInlineClassOverride2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/complexGenericMethodWithInlineClassOverride2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("complexGenericMethodWithInlineClassOverride2Generic.kt") + public void testComplexGenericMethodWithInlineClassOverride2Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/complexGenericMethodWithInlineClassOverride2Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("complexGenericMethodWithInlineClassOverride3.kt") + public void testComplexGenericMethodWithInlineClassOverride3() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/complexGenericMethodWithInlineClassOverride3.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("complexGenericMethodWithInlineClassOverride3Generic.kt") + public void testComplexGenericMethodWithInlineClassOverride3Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/complexGenericMethodWithInlineClassOverride3Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("complexGenericMethodWithInlineClassOverrideGeneric.kt") + public void testComplexGenericMethodWithInlineClassOverrideGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/complexGenericMethodWithInlineClassOverrideGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("defaultInterfaceExtensionFunCall.kt") + public void testDefaultInterfaceExtensionFunCall() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/defaultInterfaceExtensionFunCall.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("defaultInterfaceExtensionFunCallGeneric.kt") + public void testDefaultInterfaceExtensionFunCallGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/defaultInterfaceExtensionFunCallGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("defaultInterfaceMethodCall.kt") + public void testDefaultInterfaceMethodCall() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/defaultInterfaceMethodCall.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("defaultInterfaceMethodCallGeneric.kt") + public void testDefaultInterfaceMethodCallGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/defaultInterfaceMethodCallGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("genericDefaultInterfaceExtensionFunCall.kt") + public void testGenericDefaultInterfaceExtensionFunCall() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/genericDefaultInterfaceExtensionFunCall.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("genericDefaultInterfaceExtensionFunCallGeneric.kt") + public void testGenericDefaultInterfaceExtensionFunCallGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/genericDefaultInterfaceExtensionFunCallGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("genericDefaultInterfaceMethodCall.kt") + public void testGenericDefaultInterfaceMethodCall() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/genericDefaultInterfaceMethodCall.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("genericDefaultInterfaceMethodCallGeneric.kt") + public void testGenericDefaultInterfaceMethodCallGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/genericDefaultInterfaceMethodCallGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("genericInterfaceMethodCall.kt") + public void testGenericInterfaceMethodCall() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/genericInterfaceMethodCall.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("genericInterfaceMethodCallGeneric.kt") + public void testGenericInterfaceMethodCallGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/genericInterfaceMethodCallGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("genericMethodWithInlineClassOverride.kt") + public void testGenericMethodWithInlineClassOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/genericMethodWithInlineClassOverride.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("genericMethodWithInlineClassOverrideGeneric.kt") + public void testGenericMethodWithInlineClassOverrideGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/genericMethodWithInlineClassOverrideGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("interfaceSuperCall.kt") + public void testInterfaceSuperCall() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/interfaceSuperCall.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("interfaceSuperCallGeneric.kt") + public void testInterfaceSuperCallGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/interfaceSuperCallGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overriddenDefaultInterfaceMethodCall.kt") + public void testOverriddenDefaultInterfaceMethodCall() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/overriddenDefaultInterfaceMethodCall.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("overriddenDefaultInterfaceMethodCallGeneric.kt") + public void testOverriddenDefaultInterfaceMethodCallGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/interfaceMethodCalls/overriddenDefaultInterfaceMethodCallGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/javaInterop") + @TestDataPath("$PROJECT_ROOT") + public class JavaInterop { + @Test + public void testAllFilesPresentInJavaInterop() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/javaInterop"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods") + @TestDataPath("$PROJECT_ROOT") + public class Jvm8DefaultInterfaceMethods { + @Test + public void testAllFilesPresentInJvm8DefaultInterfaceMethods() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/jvm8DefaultInterfaceMethods"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/propertyDelegation") + @TestDataPath("$PROJECT_ROOT") + public class PropertyDelegation { + @Test + public void testAllFilesPresentInPropertyDelegation() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/propertyDelegation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("captureLocalVarDelegatedToInlineClass.kt") + public void testCaptureLocalVarDelegatedToInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/captureLocalVarDelegatedToInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("captureLocalVarDelegatedToInlineClassGeneric.kt") + public void testCaptureLocalVarDelegatedToInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/captureLocalVarDelegatedToInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("delegateClassVarToInlineClass.kt") + public void testDelegateClassVarToInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateClassVarToInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("delegateClassVarToInlineClassGeneric.kt") + public void testDelegateClassVarToInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateClassVarToInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("delegateClassVarToInlineClassWithProvideDelegate.kt") + public void testDelegateClassVarToInlineClassWithProvideDelegate() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateClassVarToInlineClassWithProvideDelegate.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("delegateClassVarToInlineClassWithProvideDelegateGeneric.kt") + public void testDelegateClassVarToInlineClassWithProvideDelegateGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateClassVarToInlineClassWithProvideDelegateGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("delegateCompanionVarToInlineClass.kt") + public void testDelegateCompanionVarToInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateCompanionVarToInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("delegateCompanionVarToInlineClassGeneric.kt") + public void testDelegateCompanionVarToInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateCompanionVarToInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("delegateLocalVarToInlineClass.kt") + public void testDelegateLocalVarToInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateLocalVarToInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("delegateLocalVarToInlineClassGeneric.kt") + public void testDelegateLocalVarToInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateLocalVarToInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("delegateObjectVarToInlineClass.kt") + public void testDelegateObjectVarToInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateObjectVarToInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("delegateObjectVarToInlineClassGeneric.kt") + public void testDelegateObjectVarToInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateObjectVarToInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("delegatePrivateCompanionVarToInlineClass.kt") + public void testDelegatePrivateCompanionVarToInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegatePrivateCompanionVarToInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("delegatePrivateCompanionVarToInlineClassGeneric.kt") + public void testDelegatePrivateCompanionVarToInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegatePrivateCompanionVarToInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("delegateTopLevelVarToInlineClass.kt") + public void testDelegateTopLevelVarToInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateTopLevelVarToInlineClass.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("delegateTopLevelVarToInlineClassGeneric.kt") + public void testDelegateTopLevelVarToInlineClassGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegateTopLevelVarToInlineClassGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("delegatedPropertyOfInlineClassType.kt") + public void testDelegatedPropertyOfInlineClassType() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegatedPropertyOfInlineClassType.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("delegatedPropertyOfInlineClassTypeGeneric.kt") + public void testDelegatedPropertyOfInlineClassTypeGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/delegatedPropertyOfInlineClassTypeGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27070.kt") + public void testKt27070() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/kt27070.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt27070Generic.kt") + public void testKt27070Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/kt27070Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt42933.kt") + public void testKt42933() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/kt42933.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("kt42933Generic.kt") + public void testKt42933Generic() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/propertyDelegation/kt42933Generic.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/result") + @TestDataPath("$PROJECT_ROOT") + public class Result { + @Test + public void testAllFilesPresentInResult() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/result"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("directCall1.kt") + public void testDirectCall1() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/directCall1.kt"); + } + + @Test + @TestMetadata("directCall2.kt") + public void testDirectCall2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/directCall2.kt"); + } + + @Test + @TestMetadata("doubleOverride.kt") + public void testDoubleOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/doubleOverride.kt"); + } + + @Test + @TestMetadata("extensionOverride.kt") + public void testExtensionOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/extensionOverride.kt"); + } + + @Test + @TestMetadata("inlineMethodOnResult.kt") + public void testInlineMethodOnResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/inlineMethodOnResult.kt"); + } + + @Test + @TestMetadata("lambdaTakesResultThroughBridge.kt") + public void testLambdaTakesResultThroughBridge() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/lambdaTakesResultThroughBridge.kt"); + } + + @Test + @TestMetadata("returnGenericMultiModule.kt") + public void testReturnGenericMultiModule() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/returnGenericMultiModule.kt"); + } + + @Test + @TestMetadata("returnGenericSingleModule.kt") + public void testReturnGenericSingleModule() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/result/returnGenericSingleModule.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/returnResult") + @TestDataPath("$PROJECT_ROOT") + public class ReturnResult { + @Test + public void testAllFilesPresentInReturnResult() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/returnResult"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("class.kt") + public void testClass() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/returnResult/class.kt"); + } + + @Test + @TestMetadata("classAnyOverride.kt") + public void testClassAnyOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/returnResult/classAnyOverride.kt"); + } + + @Test + @TestMetadata("classGenericOverride.kt") + public void testClassGenericOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/returnResult/classGenericOverride.kt"); + } + + @Test + @TestMetadata("classResultOverride.kt") + public void testClassResultOverride() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/returnResult/classResultOverride.kt"); + } + + @Test + @TestMetadata("interface.kt") + public void testInterface() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/returnResult/interface.kt"); + } + + @Test + @TestMetadata("topLevel.kt") + public void testTopLevel() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/returnResult/topLevel.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter") + @TestDataPath("$PROJECT_ROOT") + public class UnboxGenericParameter { + @Test + public void testAllFilesPresentInUnboxGenericParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface") + @TestDataPath("$PROJECT_ROOT") + public class FunInterface { + @Test + public void testAllFilesPresentInFunInterface() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("any.kt") + public void testAny() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/any.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("anyGeneric.kt") + public void testAnyGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/anyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("anyN.kt") + public void testAnyN() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/anyN.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("anyNGeneric.kt") + public void testAnyNGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/anyNGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("anyNGeneric2.kt") + public void testAnyNGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/anyNGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("iface.kt") + public void testIface() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/iface.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("ifaceChild.kt") + public void testIfaceChild() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/ifaceChild.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("ifaceChildGeneric.kt") + public void testIfaceChildGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/ifaceChildGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("ifaceGeneric.kt") + public void testIfaceGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/ifaceGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("nullableResult.kt") + public void testNullableResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/nullableResult.kt"); + } + + @Test + @TestMetadata("primitive.kt") + public void testPrimitive() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/primitive.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("primitiveGeneric.kt") + public void testPrimitiveGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/primitiveGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("result.kt") + public void testResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/result.kt"); + } + + @Test + @TestMetadata("resultAny.kt") + public void testResultAny() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/resultAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("resultAnyGeneric.kt") + public void testResultAnyGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/resultAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("string.kt") + public void testString() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/string.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("stringGeneric.kt") + public void testStringGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/funInterface/stringGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda") + @TestDataPath("$PROJECT_ROOT") + public class Lambda { + @Test + public void testAllFilesPresentInLambda() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("any.kt") + public void testAny() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/any.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("anyGeneric.kt") + public void testAnyGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/anyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("anyN.kt") + public void testAnyN() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/anyN.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("anyNGeneric.kt") + public void testAnyNGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/anyNGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("anyNGeneric2.kt") + public void testAnyNGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/anyNGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("iface.kt") + public void testIface() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/iface.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("ifaceChild.kt") + public void testIfaceChild() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/ifaceChild.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("ifaceChildGeneric.kt") + public void testIfaceChildGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/ifaceChildGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("ifaceGeneric.kt") + public void testIfaceGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/ifaceGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("nullableResult.kt") + public void testNullableResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/nullableResult.kt"); + } + + @Test + @TestMetadata("primitive.kt") + public void testPrimitive() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/primitive.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("primitiveGeneric.kt") + public void testPrimitiveGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/primitiveGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("result.kt") + public void testResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/result.kt"); + } + + @Test + @TestMetadata("resultAny.kt") + public void testResultAny() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/resultAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("resultAnyGeneric.kt") + public void testResultAnyGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/resultAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("string.kt") + public void testString() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/string.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("stringGeneric.kt") + public void testStringGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/lambda/stringGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral") + @TestDataPath("$PROJECT_ROOT") + public class ObjectLiteral { + @Test + public void testAllFilesPresentInObjectLiteral() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("any.kt") + public void testAny() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/any.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("anyGeneric.kt") + public void testAnyGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/anyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("anyN.kt") + public void testAnyN() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/anyN.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("anyNGeneric.kt") + public void testAnyNGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/anyNGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("anyNGeneric2.kt") + public void testAnyNGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/anyNGeneric2.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("iface.kt") + public void testIface() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/iface.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("ifaceChild.kt") + public void testIfaceChild() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/ifaceChild.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("ifaceChildGeneric.kt") + public void testIfaceChildGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/ifaceChildGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("ifaceGeneric.kt") + public void testIfaceGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/ifaceGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("nullableResult.kt") + public void testNullableResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/nullableResult.kt"); + } + + @Test + @TestMetadata("primitive.kt") + public void testPrimitive() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/primitive.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("primitiveGeneric.kt") + public void testPrimitiveGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/primitiveGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("result.kt") + public void testResult() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/result.kt"); + } + + @Test + @TestMetadata("resultAny.kt") + public void testResultAny() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/resultAny.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("resultAnyGeneric.kt") + public void testResultAnyGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/resultAnyGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("string.kt") + public void testString() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/string.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + + @Test + @TestMetadata("stringGeneric.kt") + public void testStringGeneric() throws Exception { + runTest("compiler/testData/codegen/box/inlineClasses/unboxGenericParameter/objectLiteral/stringGeneric.kt", TransformersFunctions.getRemoveOptionalJvmInlineAnnotation()); + } + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/innerNested") + @TestDataPath("$PROJECT_ROOT") + public class InnerNested { + @Test + public void testAllFilesPresentInInnerNested() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("considerPropertyInitValueFromNestedClass.kt") + public void testConsiderPropertyInitValueFromNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/considerPropertyInitValueFromNestedClass.kt"); + } + + @Test + @TestMetadata("createNestedClass.kt") + public void testCreateNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/createNestedClass.kt"); + } + + @Test + @TestMetadata("createdNestedInOuterMember.kt") + public void testCreatedNestedInOuterMember() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/createdNestedInOuterMember.kt"); + } + + @Test + @TestMetadata("extenderNestedClass.kt") + public void testExtenderNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/extenderNestedClass.kt"); + } + + @Test + @TestMetadata("extensionFun.kt") + public void testExtensionFun() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/extensionFun.kt"); + } + + @Test + @TestMetadata("extensionToNested.kt") + public void testExtensionToNested() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/extensionToNested.kt"); + } + + @Test + @TestMetadata("importNestedClass.kt") + public void testImportNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/importNestedClass.kt"); + } + + @Test + @TestMetadata("innerGeneric.kt") + public void testInnerGeneric() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/innerGeneric.kt"); + } + + @Test + @TestMetadata("innerImplicitParameter.kt") + public void testInnerImplicitParameter() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/innerImplicitParameter.kt"); + } + + @Test + @TestMetadata("innerLabeledThis.kt") + public void testInnerLabeledThis() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/innerLabeledThis.kt"); + } + + @Test + @TestMetadata("innerSimple.kt") + public void testInnerSimple() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/innerSimple.kt"); + } + + @Test + @TestMetadata("innerWithDefaultArgument.kt") + public void testInnerWithDefaultArgument() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/innerWithDefaultArgument.kt"); + } + + @Test + @TestMetadata("innerWithDefaultInner.kt") + public void testInnerWithDefaultInner() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/innerWithDefaultInner.kt"); + } + + @Test + @TestMetadata("kt3132.kt") + public void testKt3132() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/kt3132.kt"); + } + + @Test + @TestMetadata("kt3927.kt") + public void testKt3927() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/kt3927.kt"); + } + + @Test + @TestMetadata("kt46829.kt") + public void testKt46829() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/kt46829.kt"); + } + + @Test + @TestMetadata("kt5363.kt") + public void testKt5363() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/kt5363.kt"); + } + + @Test + @TestMetadata("kt6804.kt") + public void testKt6804() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/kt6804.kt"); + } + + @Test + @TestMetadata("nestedClassInObject.kt") + public void testNestedClassInObject() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/nestedClassInObject.kt"); + } + + @Test + @TestMetadata("nestedClassObject.kt") + public void testNestedClassObject() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/nestedClassObject.kt"); + } + + @Test + @TestMetadata("nestedEnumConstant.kt") + public void testNestedEnumConstant() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/nestedEnumConstant.kt"); + } + + @Test + @TestMetadata("nestedGeneric.kt") + public void testNestedGeneric() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/nestedGeneric.kt"); + } + + @Test + @TestMetadata("nestedInPackage.kt") + public void testNestedInPackage() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/nestedInPackage.kt"); + } + + @Test + @TestMetadata("nestedInnerClass.kt") + public void testNestedInnerClass() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/nestedInnerClass.kt"); + } + + @Test + @TestMetadata("nestedObjects.kt") + public void testNestedObjects() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/nestedObjects.kt"); + } + + @Test + @TestMetadata("nestedSimple.kt") + public void testNestedSimple() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/nestedSimple.kt"); + } + + @Test + @TestMetadata("passingOuterRef.kt") + public void testPassingOuterRef() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/passingOuterRef.kt"); + } + + @Test + @TestMetadata("protectedNestedClass.kt") + public void testProtectedNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/protectedNestedClass.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/innerNested/superConstructorCall") + @TestDataPath("$PROJECT_ROOT") + public class SuperConstructorCall { + @Test + public void testAllFilesPresentInSuperConstructorCall() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/innerNested/superConstructorCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("deepInnerHierarchy.kt") + public void testDeepInnerHierarchy() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/deepInnerHierarchy.kt"); + } + + @Test + @TestMetadata("deepLocalHierarchy.kt") + public void testDeepLocalHierarchy() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/deepLocalHierarchy.kt"); + } + + @Test + @TestMetadata("innerExtendsInnerViaSecondaryConstuctor.kt") + public void testInnerExtendsInnerViaSecondaryConstuctor() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/innerExtendsInnerViaSecondaryConstuctor.kt"); + } + + @Test + @TestMetadata("innerExtendsInnerWithProperOuterCapture.kt") + public void testInnerExtendsInnerWithProperOuterCapture() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/innerExtendsInnerWithProperOuterCapture.kt"); + } + + @Test + @TestMetadata("kt11833_1.kt") + public void testKt11833_1() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/kt11833_1.kt"); + } + + @Test + @TestMetadata("kt11833_2.kt") + public void testKt11833_2() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/kt11833_2.kt"); + } + + @Test + @TestMetadata("localClassOuterDiffersFromInnerOuter.kt") + public void testLocalClassOuterDiffersFromInnerOuter() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/localClassOuterDiffersFromInnerOuter.kt"); + } + + @Test + @TestMetadata("localExtendsInner.kt") + public void testLocalExtendsInner() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/localExtendsInner.kt"); + } + + @Test + @TestMetadata("localExtendsLocalWithClosure.kt") + public void testLocalExtendsLocalWithClosure() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/localExtendsLocalWithClosure.kt"); + } + + @Test + @TestMetadata("localWithClosureExtendsLocalWithClosure.kt") + public void testLocalWithClosureExtendsLocalWithClosure() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/localWithClosureExtendsLocalWithClosure.kt"); + } + + @Test + @TestMetadata("objectExtendsClassDefaultArgument.kt") + public void testObjectExtendsClassDefaultArgument() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/objectExtendsClassDefaultArgument.kt"); + } + + @Test + @TestMetadata("objectExtendsClassVararg.kt") + public void testObjectExtendsClassVararg() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/objectExtendsClassVararg.kt"); + } + + @Test + @TestMetadata("objectExtendsInner.kt") + public void testObjectExtendsInner() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/objectExtendsInner.kt"); + } + + @Test + @TestMetadata("objectExtendsInnerDefaultArgument.kt") + public void testObjectExtendsInnerDefaultArgument() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/objectExtendsInnerDefaultArgument.kt"); + } + + @Test + @TestMetadata("objectExtendsInnerOfLocalVarargAndDefault.kt") + public void testObjectExtendsInnerOfLocalVarargAndDefault() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/objectExtendsInnerOfLocalVarargAndDefault.kt"); + } + + @Test + @TestMetadata("objectExtendsInnerOfLocalWithCapture.kt") + public void testObjectExtendsInnerOfLocalWithCapture() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/objectExtendsInnerOfLocalWithCapture.kt"); + } + + @Test + @TestMetadata("objectExtendsInnerWithDelegatingConstructor.kt") + public void testObjectExtendsInnerWithDelegatingConstructor() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/objectExtendsInnerWithDelegatingConstructor.kt"); + } + + @Test + @TestMetadata("objectExtendsLocalCaptureInSuperCall.kt") + public void testObjectExtendsLocalCaptureInSuperCall() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/objectExtendsLocalCaptureInSuperCall.kt"); + } + + @Test + @TestMetadata("objectExtendsLocalWithClosure.kt") + public void testObjectExtendsLocalWithClosure() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/objectExtendsLocalWithClosure.kt"); + } + + @Test + @TestMetadata("objectExtendsLocal_kt16858.kt") + public void testObjectExtendsLocal_kt16858() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/objectExtendsLocal_kt16858.kt"); + } + + @Test + @TestMetadata("objectOuterDiffersFromInnerOuter.kt") + public void testObjectOuterDiffersFromInnerOuter() throws Exception { + runTest("compiler/testData/codegen/box/innerNested/superConstructorCall/objectOuterDiffersFromInnerOuter.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/instructions") + @TestDataPath("$PROJECT_ROOT") + public class Instructions { + @Test + public void testAllFilesPresentInInstructions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/instructions/swap") + @TestDataPath("$PROJECT_ROOT") + public class Swap { + @Test + public void testAllFilesPresentInSwap() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/instructions/swap"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("swapRefToSharedVarInt.kt") + public void testSwapRefToSharedVarInt() throws Exception { + runTest("compiler/testData/codegen/box/instructions/swap/swapRefToSharedVarInt.kt"); + } + + @Test + @TestMetadata("swapRefToSharedVarLong.kt") + public void testSwapRefToSharedVarLong() throws Exception { + runTest("compiler/testData/codegen/box/instructions/swap/swapRefToSharedVarLong.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/intrinsics") + @TestDataPath("$PROJECT_ROOT") + public class Intrinsics { + @Test + public void testAllFilesPresentInIntrinsics() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/intrinsics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("charToInt.kt") + public void testCharToInt() throws Exception { + runTest("compiler/testData/codegen/box/intrinsics/charToInt.kt"); + } + + @Test + @TestMetadata("ea35953.kt") + public void testEa35953() throws Exception { + runTest("compiler/testData/codegen/box/intrinsics/ea35953.kt"); + } + + @Test + @TestMetadata("incWithLabel.kt") + public void testIncWithLabel() throws Exception { + runTest("compiler/testData/codegen/box/intrinsics/incWithLabel.kt"); + } + + @Test + @TestMetadata("kt10131.kt") + public void testKt10131() throws Exception { + runTest("compiler/testData/codegen/box/intrinsics/kt10131.kt"); + } + + @Test + @TestMetadata("kt10131a.kt") + public void testKt10131a() throws Exception { + runTest("compiler/testData/codegen/box/intrinsics/kt10131a.kt"); + } + + @Test + @TestMetadata("kt12125.kt") + public void testKt12125() throws Exception { + runTest("compiler/testData/codegen/box/intrinsics/kt12125.kt"); + } + + @Test + @TestMetadata("kt12125_2.kt") + public void testKt12125_2() throws Exception { + runTest("compiler/testData/codegen/box/intrinsics/kt12125_2.kt"); + } + + @Test + @TestMetadata("kt12125_inc.kt") + public void testKt12125_inc() throws Exception { + runTest("compiler/testData/codegen/box/intrinsics/kt12125_inc.kt"); + } + + @Test + @TestMetadata("kt12125_inc_2.kt") + public void testKt12125_inc_2() throws Exception { + runTest("compiler/testData/codegen/box/intrinsics/kt12125_inc_2.kt"); + } + + @Test + @TestMetadata("kt52163_boolean.kt") + public void testKt52163_boolean() throws Exception { + runTest("compiler/testData/codegen/box/intrinsics/kt52163_boolean.kt"); + } + + @Test + @TestMetadata("kt52163_doubleCompareToInt.kt") + public void testKt52163_doubleCompareToInt() throws Exception { + runTest("compiler/testData/codegen/box/intrinsics/kt52163_doubleCompareToInt.kt"); + } + + @Test + @TestMetadata("kt8666.kt") + public void testKt8666() throws Exception { + runTest("compiler/testData/codegen/box/intrinsics/kt8666.kt"); + } + + @Test + @TestMetadata("longRangeWithExplicitDot.kt") + public void testLongRangeWithExplicitDot() throws Exception { + runTest("compiler/testData/codegen/box/intrinsics/longRangeWithExplicitDot.kt"); + } + + @Test + @TestMetadata("nonShortCircuitAnd.kt") + public void testNonShortCircuitAnd() throws Exception { + runTest("compiler/testData/codegen/box/intrinsics/nonShortCircuitAnd.kt"); + } + + @Test + @TestMetadata("nullPlusString.kt") + public void testNullPlusString() throws Exception { + runTest("compiler/testData/codegen/box/intrinsics/nullPlusString.kt"); + } + + @Test + @TestMetadata("prefixIncDec.kt") + public void testPrefixIncDec() throws Exception { + runTest("compiler/testData/codegen/box/intrinsics/prefixIncDec.kt"); + } + + @Test + @TestMetadata("rangeFromCollection.kt") + public void testRangeFromCollection() throws Exception { + runTest("compiler/testData/codegen/box/intrinsics/rangeFromCollection.kt"); + } + + @Test + @TestMetadata("stringFromCollection.kt") + public void testStringFromCollection() throws Exception { + runTest("compiler/testData/codegen/box/intrinsics/stringFromCollection.kt"); + } + + @Test + @TestMetadata("throwableParamOrder.kt") + public void testThrowableParamOrder() throws Exception { + runTest("compiler/testData/codegen/box/intrinsics/throwableParamOrder.kt"); + } + + @Test + @TestMetadata("tostring.kt") + public void testTostring() throws Exception { + runTest("compiler/testData/codegen/box/intrinsics/tostring.kt"); + } + + @Test + @TestMetadata("trimMarginWithBlankString.kt") + public void testTrimMarginWithBlankString() throws Exception { + runTest("compiler/testData/codegen/box/intrinsics/trimMarginWithBlankString.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/invokedynamic") + @TestDataPath("$PROJECT_ROOT") + public class Invokedynamic { + @Test + public void testAllFilesPresentInInvokedynamic() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/invokedynamic"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/invokedynamic/lambdas") + @TestDataPath("$PROJECT_ROOT") + public class Lambdas { + @Test + public void testAllFilesPresentInLambdas() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/invokedynamic/lambdas"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt52875.kt") + public void testKt52875() throws Exception { + runTest("compiler/testData/codegen/box/invokedynamic/lambdas/kt52875.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/invokedynamic/lambdas/inlineClassInSignature") + @TestDataPath("$PROJECT_ROOT") + public class InlineClassInSignature { + @Test + public void testAllFilesPresentInInlineClassInSignature() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/invokedynamic/lambdas/inlineClassInSignature"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/invokedynamic/sam") + @TestDataPath("$PROJECT_ROOT") + public class Sam { + @Test + public void testAllFilesPresentInSam() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/invokedynamic/sam"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/invokedynamic/sam/functionExprToJavaInterface") + @TestDataPath("$PROJECT_ROOT") + public class FunctionExprToJavaInterface { + @Test + public void testAllFilesPresentInFunctionExprToJavaInterface() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/invokedynamic/sam/functionExprToJavaInterface"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/invokedynamic/sam/functionRefToJavaInterface") + @TestDataPath("$PROJECT_ROOT") + public class FunctionRefToJavaInterface { + @Test + public void testAllFilesPresentInFunctionRefToJavaInterface() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/invokedynamic/sam/functionRefToJavaInterface"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/invokedynamic/sam/functionRefToJavaInterface/specialFunctions") + @TestDataPath("$PROJECT_ROOT") + public class SpecialFunctions { + @Test + public void testAllFilesPresentInSpecialFunctions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/invokedynamic/sam/functionRefToJavaInterface/specialFunctions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/invokedynamic/sam/functionRefToJavaInterface/withAccessor") + @TestDataPath("$PROJECT_ROOT") + public class WithAccessor { + @Test + public void testAllFilesPresentInWithAccessor() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/invokedynamic/sam/functionRefToJavaInterface/withAccessor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/invokedynamic/sam/inlineClassInSignature") + @TestDataPath("$PROJECT_ROOT") + public class InlineClassInSignature { + @Test + public void testAllFilesPresentInInlineClassInSignature() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/invokedynamic/sam/inlineClassInSignature"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/invokedynamic/sam/specializedGenerics") + @TestDataPath("$PROJECT_ROOT") + public class SpecializedGenerics { + @Test + public void testAllFilesPresentInSpecializedGenerics() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/invokedynamic/sam/specializedGenerics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/invokedynamic/serializable") + @TestDataPath("$PROJECT_ROOT") + public class Serializable { + @Test + public void testAllFilesPresentInSerializable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/invokedynamic/serializable"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/involvesIrInterpreter") + @TestDataPath("$PROJECT_ROOT") + public class InvolvesIrInterpreter { + @Test + public void testAllFilesPresentInInvolvesIrInterpreter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/involvesIrInterpreter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt55912.kt") + public void testKt55912() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/kt55912.kt"); + } + + @Test + @TestMetadata("kt56215.kt") + public void testKt56215() throws Exception { + runTest("compiler/testData/codegen/box/involvesIrInterpreter/kt56215.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/involvesIrInterpreter/intrinsicConst") + @TestDataPath("$PROJECT_ROOT") + public class IntrinsicConst { + @Test + public void testAllFilesPresentInIntrinsicConst() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/involvesIrInterpreter/intrinsicConst"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/involvesIrInterpreter/serialization") + @TestDataPath("$PROJECT_ROOT") + public class Serialization { + @Test + public void testAllFilesPresentInSerialization() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/involvesIrInterpreter/serialization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ir") + @TestDataPath("$PROJECT_ROOT") + public class Ir { + @Test + public void testAllFilesPresentInIr() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("anonymousClassLeak.kt") + public void testAnonymousClassLeak() throws Exception { + runTest("compiler/testData/codegen/box/ir/anonymousClassLeak.kt"); + } + + @Test + @TestMetadata("anonymousObjectInForLoopIteratorAndBody.kt") + public void testAnonymousObjectInForLoopIteratorAndBody() throws Exception { + runTest("compiler/testData/codegen/box/ir/anonymousObjectInForLoopIteratorAndBody.kt"); + } + + @Test + @TestMetadata("anonymousObjectInGenericFun.kt") + public void testAnonymousObjectInGenericFun() throws Exception { + runTest("compiler/testData/codegen/box/ir/anonymousObjectInGenericFun.kt"); + } + + @Test + @TestMetadata("anonymousObjectInsideElvis.kt") + public void testAnonymousObjectInsideElvis() throws Exception { + runTest("compiler/testData/codegen/box/ir/anonymousObjectInsideElvis.kt"); + } + + @Test + @TestMetadata("classInitializers.kt") + public void testClassInitializers() throws Exception { + runTest("compiler/testData/codegen/box/ir/classInitializers.kt"); + } + + @Test + @TestMetadata("enumClass.kt") + public void testEnumClass() throws Exception { + runTest("compiler/testData/codegen/box/ir/enumClass.kt"); + } + + @Test + @TestMetadata("enumClass2.kt") + public void testEnumClass2() throws Exception { + runTest("compiler/testData/codegen/box/ir/enumClass2.kt"); + } + + @Test + @TestMetadata("enumClass3.kt") + public void testEnumClass3() throws Exception { + runTest("compiler/testData/codegen/box/ir/enumClass3.kt"); + } + + @Test + @TestMetadata("fileClassInitializers.kt") + public void testFileClassInitializers() throws Exception { + runTest("compiler/testData/codegen/box/ir/fileClassInitializers.kt"); + } + + @Test + @TestMetadata("genericCompanion.kt") + public void testGenericCompanion() throws Exception { + runTest("compiler/testData/codegen/box/ir/genericCompanion.kt"); + } + + @Test + @TestMetadata("hashCodeOnGenericSubstitutedWithPrimitive.kt") + public void testHashCodeOnGenericSubstitutedWithPrimitive() throws Exception { + runTest("compiler/testData/codegen/box/ir/hashCodeOnGenericSubstitutedWithPrimitive.kt"); + } + + @Test + @TestMetadata("kt25405.kt") + public void testKt25405() throws Exception { + runTest("compiler/testData/codegen/box/ir/kt25405.kt"); + } + + @Test + @TestMetadata("kt40083.kt") + public void testKt40083() throws Exception { + runTest("compiler/testData/codegen/box/ir/kt40083.kt"); + } + + @Test + @TestMetadata("kt41765.kt") + public void testKt41765() throws Exception { + runTest("compiler/testData/codegen/box/ir/kt41765.kt"); + } + + @Test + @TestMetadata("kt52677.kt") + public void testKt52677() throws Exception { + runTest("compiler/testData/codegen/box/ir/kt52677.kt"); + } + + @Test + @TestMetadata("kt55318.kt") + public void testKt55318() throws Exception { + runTest("compiler/testData/codegen/box/ir/kt55318.kt"); + } + + @Test + @TestMetadata("lambdaWithLoop.kt") + public void testLambdaWithLoop() throws Exception { + runTest("compiler/testData/codegen/box/ir/lambdaWithLoop.kt"); + } + + @Test + @TestMetadata("objectClass.kt") + public void testObjectClass() throws Exception { + runTest("compiler/testData/codegen/box/ir/objectClass.kt"); + } + + @Test + @TestMetadata("recursiveGeneric.kt") + public void testRecursiveGeneric() throws Exception { + runTest("compiler/testData/codegen/box/ir/recursiveGeneric.kt"); + } + + @Test + @TestMetadata("recursiveGeneric2.kt") + public void testRecursiveGeneric2() throws Exception { + runTest("compiler/testData/codegen/box/ir/recursiveGeneric2.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/ir/simple.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ir/closureConversion") + @TestDataPath("$PROJECT_ROOT") + public class ClosureConversion { + @Test + public void testAllFilesPresentInClosureConversion() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/closureConversion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("closureConversion1.kt") + public void testClosureConversion1() throws Exception { + runTest("compiler/testData/codegen/box/ir/closureConversion/closureConversion1.kt"); + } + + @Test + @TestMetadata("closureConversion2.kt") + public void testClosureConversion2() throws Exception { + runTest("compiler/testData/codegen/box/ir/closureConversion/closureConversion2.kt"); + } + + @Test + @TestMetadata("closureConversion3.kt") + public void testClosureConversion3() throws Exception { + runTest("compiler/testData/codegen/box/ir/closureConversion/closureConversion3.kt"); + } + + @Test + @TestMetadata("closureConversion4.kt") + public void testClosureConversion4() throws Exception { + runTest("compiler/testData/codegen/box/ir/closureConversion/closureConversion4.kt"); + } + + @Test + @TestMetadata("innerClass1.kt") + public void testInnerClass1() throws Exception { + runTest("compiler/testData/codegen/box/ir/closureConversion/innerClass1.kt"); + } + + @Test + @TestMetadata("innerClass2.kt") + public void testInnerClass2() throws Exception { + runTest("compiler/testData/codegen/box/ir/closureConversion/innerClass2.kt"); + } + + @Test + @TestMetadata("mutable1.kt") + public void testMutable1() throws Exception { + runTest("compiler/testData/codegen/box/ir/closureConversion/mutable1.kt"); + } + + @Test + @TestMetadata("mutablePrimitives.kt") + public void testMutablePrimitives() throws Exception { + runTest("compiler/testData/codegen/box/ir/closureConversion/mutablePrimitives.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ir/primitiveNumberComparisons") + @TestDataPath("$PROJECT_ROOT") + public class PrimitiveNumberComparisons { + @Test + public void testAllFilesPresentInPrimitiveNumberComparisons() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/primitiveNumberComparisons"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("comparableToDouble.kt") + public void testComparableToDouble() throws Exception { + runTest("compiler/testData/codegen/box/ir/primitiveNumberComparisons/comparableToDouble.kt"); + } + + @Test + @TestMetadata("doubleEqeq.kt") + public void testDoubleEqeq() throws Exception { + runTest("compiler/testData/codegen/box/ir/primitiveNumberComparisons/doubleEqeq.kt"); + } + + @Test + @TestMetadata("floatEqeq.kt") + public void testFloatEqeq() throws Exception { + runTest("compiler/testData/codegen/box/ir/primitiveNumberComparisons/floatEqeq.kt"); + } + + @Test + @TestMetadata("mixedNumberTypes.kt") + public void testMixedNumberTypes() throws Exception { + runTest("compiler/testData/codegen/box/ir/primitiveNumberComparisons/mixedNumberTypes.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ir/privateSignatures") + @TestDataPath("$PROJECT_ROOT") + public class PrivateSignatures { + @Test + public void testAllFilesPresentInPrivateSignatures() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/privateSignatures"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("enumEntryArguments.kt") + public void testEnumEntryArguments() throws Exception { + runTest("compiler/testData/codegen/box/ir/privateSignatures/enumEntryArguments.kt"); + } + + @Test + @TestMetadata("privateLeakThroughInline.kt") + public void testPrivateLeakThroughInline() throws Exception { + runTest("compiler/testData/codegen/box/ir/privateSignatures/privateLeakThroughInline.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ir/serializationRegressions") + @TestDataPath("$PROJECT_ROOT") + public class SerializationRegressions { + @Test + public void testAllFilesPresentInSerializationRegressions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ir/serializationRegressions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("anonFakeOverride.kt") + public void testAnonFakeOverride() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/anonFakeOverride.kt"); + } + + @Test + @TestMetadata("deepGenericDelegatedProperty.kt") + public void testDeepGenericDelegatedProperty() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/deepGenericDelegatedProperty.kt"); + } + + @Test + @TestMetadata("dispatchReceiverValue.kt") + public void testDispatchReceiverValue() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/dispatchReceiverValue.kt"); + } + + @Test + @TestMetadata("genericProperty.kt") + public void testGenericProperty() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/genericProperty.kt"); + } + + @Test + @TestMetadata("innerClassInEnumEntryClass.kt") + public void testInnerClassInEnumEntryClass() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/innerClassInEnumEntryClass.kt"); + } + + @Test + @TestMetadata("signatureClash.kt") + public void testSignatureClash() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/signatureClash.kt"); + } + + @Test + @TestMetadata("transitiveClash.kt") + public void testTransitiveClash() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/transitiveClash.kt"); + } + + @Test + @TestMetadata("useImportedMember.kt") + public void testUseImportedMember() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/useImportedMember.kt"); + } + + @Test + @TestMetadata("varAsFunctionCall.kt") + public void testVarAsFunctionCall() throws Exception { + runTest("compiler/testData/codegen/box/ir/serializationRegressions/varAsFunctionCall.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/javaFieldAndKotlinProperty") + @TestDataPath("$PROJECT_ROOT") + public class JavaFieldAndKotlinProperty { + @Test + public void testAllFilesPresentInJavaFieldAndKotlinProperty() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaFieldAndKotlinProperty"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/javaInterop") + @TestDataPath("$PROJECT_ROOT") + public class JavaInterop { + @Test + public void testAllFilesPresentInJavaInterop() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/javaInterop/foreignAnnotationsTests") + @TestDataPath("$PROJECT_ROOT") + public class ForeignAnnotationsTests { + @Test + public void testAllFilesPresentInForeignAnnotationsTests() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/foreignAnnotationsTests"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/javaInterop/foreignAnnotationsTests/tests") + @TestDataPath("$PROJECT_ROOT") + public class Tests { + @Test + public void testAllFilesPresentInTests() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/foreignAnnotationsTests/tests"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/javaInterop/generics") + @TestDataPath("$PROJECT_ROOT") + public class Generics { + @Test + public void testAllFilesPresentInGenerics() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/generics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/javaInterop/notNullAssertions") + @TestDataPath("$PROJECT_ROOT") + public class NotNullAssertions { + @Test + public void testAllFilesPresentInNotNullAssertions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("mapPut.kt") + public void testMapPut() throws Exception { + runTest("compiler/testData/codegen/box/javaInterop/notNullAssertions/mapPut.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/javaInterop/notNullAssertions/enhancedNullability") + @TestDataPath("$PROJECT_ROOT") + public class EnhancedNullability { + @Test + public void testAllFilesPresentInEnhancedNullability() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/enhancedNullability"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/javaInterop/notNullAssertions/expressionAssertionMessages") + @TestDataPath("$PROJECT_ROOT") + public class ExpressionAssertionMessages { + @Test + public void testAllFilesPresentInExpressionAssertionMessages() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/expressionAssertionMessages"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/javaInterop/notNullAssertions/nullCheckOnLambdaReturnValue") + @TestDataPath("$PROJECT_ROOT") + public class NullCheckOnLambdaReturnValue { + @Test + public void testAllFilesPresentInNullCheckOnLambdaReturnValue() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/notNullAssertions/nullCheckOnLambdaReturnValue"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/javaInterop/objectMethods") + @TestDataPath("$PROJECT_ROOT") + public class ObjectMethods { + @Test + public void testAllFilesPresentInObjectMethods() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaInterop/objectMethods"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/javaVisibility") + @TestDataPath("$PROJECT_ROOT") + public class JavaVisibility { + @Test + public void testAllFilesPresentInJavaVisibility() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaVisibility"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/javaVisibility/package") + @TestDataPath("$PROJECT_ROOT") + public class Package { + @Test + public void testAllFilesPresentInPackage() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaVisibility/package"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/javaVisibility/protectedAndPackage") + @TestDataPath("$PROJECT_ROOT") + public class ProtectedAndPackage { + @Test + public void testAllFilesPresentInProtectedAndPackage() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaVisibility/protectedAndPackage"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/javaVisibility/protectedStatic") + @TestDataPath("$PROJECT_ROOT") + public class ProtectedStatic { + @Test + public void testAllFilesPresentInProtectedStatic() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/javaVisibility/protectedStatic"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/jdk") + @TestDataPath("$PROJECT_ROOT") + public class Jdk { + @Test + public void testAllFilesPresentInJdk() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jdk"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("arrayList.kt") + public void testArrayList() throws Exception { + runTest("compiler/testData/codegen/box/jdk/arrayList.kt"); + } + + @Test + @TestMetadata("hashMap.kt") + public void testHashMap() throws Exception { + runTest("compiler/testData/codegen/box/jdk/hashMap.kt"); + } + + @Test + @TestMetadata("iteratingOverHashMap.kt") + public void testIteratingOverHashMap() throws Exception { + runTest("compiler/testData/codegen/box/jdk/iteratingOverHashMap.kt"); + } + + @Test + @TestMetadata("kt1397.kt") + public void testKt1397() throws Exception { + runTest("compiler/testData/codegen/box/jdk/kt1397.kt"); + } + + @Test + @TestMetadata("noStringToCharArray.kt") + public void testNoStringToCharArray() throws Exception { + runTest("compiler/testData/codegen/box/jdk/noStringToCharArray.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/js") + @TestDataPath("$PROJECT_ROOT") + public class Js { + @Test + public void testAllFilesPresentInJs() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/js"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/jvm8") + @TestDataPath("$PROJECT_ROOT") + public class Jvm8 { + @Test + public void testAllFilesPresentInJvm8() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/jvm8/defaults") + @TestDataPath("$PROJECT_ROOT") + public class Defaults { + @Test + public void testAllFilesPresentInDefaults() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/allCompatibility") + @TestDataPath("$PROJECT_ROOT") + public class AllCompatibility { + @Test + public void testAllFilesPresentInAllCompatibility() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/delegationBy") + @TestDataPath("$PROJECT_ROOT") + public class DelegationBy { + @Test + public void testAllFilesPresentInDelegationBy() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/allCompatibility/delegationBy"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/delegationBy") + @TestDataPath("$PROJECT_ROOT") + public class DelegationBy { + @Test + public void testAllFilesPresentInDelegationBy() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/delegationBy"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls") + @TestDataPath("$PROJECT_ROOT") + public class NoDefaultImpls { + @Test + public void testAllFilesPresentInNoDefaultImpls() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/delegationBy") + @TestDataPath("$PROJECT_ROOT") + public class DelegationBy { + @Test + public void testAllFilesPresentInDelegationBy() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/delegationBy"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/specialization") + @TestDataPath("$PROJECT_ROOT") + public class Specialization { + @Test + public void testAllFilesPresentInSpecialization() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/specialization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/withCompatibility") + @TestDataPath("$PROJECT_ROOT") + public class WithCompatibility { + @Test + public void testAllFilesPresentInWithCompatibility() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/noDefaultImpls/withCompatibility"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance") + @TestDataPath("$PROJECT_ROOT") + public class NonDefaultInheritance { + @Test + public void testAllFilesPresentInNonDefaultInheritance() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/nonDefaultInheritance"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/jvm8/defaults/reflection") + @TestDataPath("$PROJECT_ROOT") + public class Reflection { + @Test + public void testAllFilesPresentInReflection() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/defaults/reflection"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/jvm8/interfaceFlag") + @TestDataPath("$PROJECT_ROOT") + public class InterfaceFlag { + @Test + public void testAllFilesPresentInInterfaceFlag() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/interfaceFlag"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/jvm8/javaDefaults") + @TestDataPath("$PROJECT_ROOT") + public class JavaDefaults { + @Test + public void testAllFilesPresentInJavaDefaults() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvm8/javaDefaults"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/jvmField") + @TestDataPath("$PROJECT_ROOT") + public class JvmField { + @Test + public void testAllFilesPresentInJvmField() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmField"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/jvmName") + @TestDataPath("$PROJECT_ROOT") + public class JvmName { + @Test + public void testAllFilesPresentInJvmName() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/jvmName/fileFacades") + @TestDataPath("$PROJECT_ROOT") + public class FileFacades { + @Test + public void testAllFilesPresentInFileFacades() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmName/fileFacades"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/jvmOverloads") + @TestDataPath("$PROJECT_ROOT") + public class JvmOverloads { + @Test + public void testAllFilesPresentInJvmOverloads() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmOverloads"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/jvmPackageName") + @TestDataPath("$PROJECT_ROOT") + public class JvmPackageName { + @Test + public void testAllFilesPresentInJvmPackageName() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmPackageName"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/jvmStatic") + @TestDataPath("$PROJECT_ROOT") + public class JvmStatic { + @Test + public void testAllFilesPresentInJvmStatic() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmStatic"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/jvmStatic/protectedInSuperClass") + @TestDataPath("$PROJECT_ROOT") + public class ProtectedInSuperClass { + @Test + public void testAllFilesPresentInProtectedInSuperClass() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/jvmStatic/protectedInSuperClass"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/labels") + @TestDataPath("$PROJECT_ROOT") + public class Labels { + @Test + public void testAllFilesPresentInLabels() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/labels"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("controlLabelClashesWithFuncitonName.kt") + public void testControlLabelClashesWithFuncitonName() throws Exception { + runTest("compiler/testData/codegen/box/labels/controlLabelClashesWithFuncitonName.kt"); + } + + @Test + @TestMetadata("infixCallLabelling.kt") + public void testInfixCallLabelling() throws Exception { + runTest("compiler/testData/codegen/box/labels/infixCallLabelling.kt"); + } + + @Test + @TestMetadata("labeledDeclarations.kt") + public void testLabeledDeclarations() throws Exception { + runTest("compiler/testData/codegen/box/labels/labeledDeclarations.kt"); + } + + @Test + @TestMetadata("propertyAccessor.kt") + public void testPropertyAccessor() throws Exception { + runTest("compiler/testData/codegen/box/labels/propertyAccessor.kt"); + } + + @Test + @TestMetadata("propertyAccessorFunctionLiteral.kt") + public void testPropertyAccessorFunctionLiteral() throws Exception { + runTest("compiler/testData/codegen/box/labels/propertyAccessorFunctionLiteral.kt"); + } + + @Test + @TestMetadata("propertyAccessorInnerExtensionFun.kt") + public void testPropertyAccessorInnerExtensionFun() throws Exception { + runTest("compiler/testData/codegen/box/labels/propertyAccessorInnerExtensionFun.kt"); + } + + @Test + @TestMetadata("propertyAccessorObject.kt") + public void testPropertyAccessorObject() throws Exception { + runTest("compiler/testData/codegen/box/labels/propertyAccessorObject.kt"); + } + + @Test + @TestMetadata("propertyInClassAccessor.kt") + public void testPropertyInClassAccessor() throws Exception { + runTest("compiler/testData/codegen/box/labels/propertyInClassAccessor.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/lazyCodegen") + @TestDataPath("$PROJECT_ROOT") + public class LazyCodegen { + @Test + public void testAllFilesPresentInLazyCodegen() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("exceptionInFieldInitializer.kt") + public void testExceptionInFieldInitializer() throws Exception { + runTest("compiler/testData/codegen/box/lazyCodegen/exceptionInFieldInitializer.kt"); + } + + @Test + @TestMetadata("ifElse.kt") + public void testIfElse() throws Exception { + runTest("compiler/testData/codegen/box/lazyCodegen/ifElse.kt"); + } + + @Test + @TestMetadata("increment.kt") + public void testIncrement() throws Exception { + runTest("compiler/testData/codegen/box/lazyCodegen/increment.kt"); + } + + @Test + @TestMetadata("safeAssign.kt") + public void testSafeAssign() throws Exception { + runTest("compiler/testData/codegen/box/lazyCodegen/safeAssign.kt"); + } + + @Test + @TestMetadata("safeAssignComplex.kt") + public void testSafeAssignComplex() throws Exception { + runTest("compiler/testData/codegen/box/lazyCodegen/safeAssignComplex.kt"); + } + + @Test + @TestMetadata("safeCallAndArray.kt") + public void testSafeCallAndArray() throws Exception { + runTest("compiler/testData/codegen/box/lazyCodegen/safeCallAndArray.kt"); + } + + @Test + @TestMetadata("toString.kt") + public void testToString() throws Exception { + runTest("compiler/testData/codegen/box/lazyCodegen/toString.kt"); + } + + @Test + @TestMetadata("tryCatchExpression.kt") + public void testTryCatchExpression() throws Exception { + runTest("compiler/testData/codegen/box/lazyCodegen/tryCatchExpression.kt"); + } + + @Test + @TestMetadata("when.kt") + public void testWhen() throws Exception { + runTest("compiler/testData/codegen/box/lazyCodegen/when.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/lazyCodegen/optimizations") + @TestDataPath("$PROJECT_ROOT") + public class Optimizations { + @Test + public void testAllFilesPresentInOptimizations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/lazyCodegen/optimizations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("negateConstantCompare.kt") + public void testNegateConstantCompare() throws Exception { + runTest("compiler/testData/codegen/box/lazyCodegen/optimizations/negateConstantCompare.kt"); + } + + @Test + @TestMetadata("negateFalse.kt") + public void testNegateFalse() throws Exception { + runTest("compiler/testData/codegen/box/lazyCodegen/optimizations/negateFalse.kt"); + } + + @Test + @TestMetadata("negateFalseVar.kt") + public void testNegateFalseVar() throws Exception { + runTest("compiler/testData/codegen/box/lazyCodegen/optimizations/negateFalseVar.kt"); + } + + @Test + @TestMetadata("negateFalseVarChain.kt") + public void testNegateFalseVarChain() throws Exception { + runTest("compiler/testData/codegen/box/lazyCodegen/optimizations/negateFalseVarChain.kt"); + } + + @Test + @TestMetadata("negateObjectComp.kt") + public void testNegateObjectComp() throws Exception { + runTest("compiler/testData/codegen/box/lazyCodegen/optimizations/negateObjectComp.kt"); + } + + @Test + @TestMetadata("negateObjectComp2.kt") + public void testNegateObjectComp2() throws Exception { + runTest("compiler/testData/codegen/box/lazyCodegen/optimizations/negateObjectComp2.kt"); + } + + @Test + @TestMetadata("negateTrue.kt") + public void testNegateTrue() throws Exception { + runTest("compiler/testData/codegen/box/lazyCodegen/optimizations/negateTrue.kt"); + } + + @Test + @TestMetadata("negateTrueVar.kt") + public void testNegateTrueVar() throws Exception { + runTest("compiler/testData/codegen/box/lazyCodegen/optimizations/negateTrueVar.kt"); + } + + @Test + @TestMetadata("noOptimization.kt") + public void testNoOptimization() throws Exception { + runTest("compiler/testData/codegen/box/lazyCodegen/optimizations/noOptimization.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/localClasses") + @TestDataPath("$PROJECT_ROOT") + public class LocalClasses { + @Test + public void testAllFilesPresentInLocalClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/localClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("anonymousObjectInExtension.kt") + public void testAnonymousObjectInExtension() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/anonymousObjectInExtension.kt"); + } + + @Test + @TestMetadata("anonymousObjectInInitializer.kt") + public void testAnonymousObjectInInitializer() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/anonymousObjectInInitializer.kt"); + } + + @Test + @TestMetadata("anonymousObjectInParameterInitializer.kt") + public void testAnonymousObjectInParameterInitializer() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/anonymousObjectInParameterInitializer.kt"); + } + + @Test + @TestMetadata("capturingInDefaultConstructorParameter.kt") + public void testCapturingInDefaultConstructorParameter() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/capturingInDefaultConstructorParameter.kt"); + } + + @Test + @TestMetadata("closureOfInnerLocalClass.kt") + public void testClosureOfInnerLocalClass() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/closureOfInnerLocalClass.kt"); + } + + @Test + @TestMetadata("closureOfLambdaInLocalClass.kt") + public void testClosureOfLambdaInLocalClass() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/closureOfLambdaInLocalClass.kt"); + } + + @Test + @TestMetadata("closureWithSelfInstantiation.kt") + public void testClosureWithSelfInstantiation() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/closureWithSelfInstantiation.kt"); + } + + @Test + @TestMetadata("defaultParameterInConstructor.kt") + public void testDefaultParameterInConstructor() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/defaultParameterInConstructor.kt"); + } + + @Test + @TestMetadata("inExtensionFunction.kt") + public void testInExtensionFunction() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/inExtensionFunction.kt"); + } + + @Test + @TestMetadata("inExtensionProperty.kt") + public void testInExtensionProperty() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/inExtensionProperty.kt"); + } + + @Test + @TestMetadata("inLocalExtensionFunction.kt") + public void testInLocalExtensionFunction() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/inLocalExtensionFunction.kt"); + } + + @Test + @TestMetadata("inLocalExtensionProperty.kt") + public void testInLocalExtensionProperty() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/inLocalExtensionProperty.kt"); + } + + @Test + @TestMetadata("innerClassInLocalClass.kt") + public void testInnerClassInLocalClass() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/innerClassInLocalClass.kt"); + } + + @Test + @TestMetadata("innerOfLocalCaptureExtensionReceiver.kt") + public void testInnerOfLocalCaptureExtensionReceiver() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/innerOfLocalCaptureExtensionReceiver.kt"); + } + + @Test + @TestMetadata("kt10835.kt") + public void testKt10835() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/kt10835.kt"); + } + + @Test + @TestMetadata("kt10835a.kt") + public void testKt10835a() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/kt10835a.kt"); + } + + @Test + @TestMetadata("kt2700.kt") + public void testKt2700() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/kt2700.kt"); + } + + @Test + @TestMetadata("kt2873.kt") + public void testKt2873() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/kt2873.kt"); + } + + @Test + @TestMetadata("kt3210.kt") + public void testKt3210() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/kt3210.kt"); + } + + @Test + @TestMetadata("kt3389.kt") + public void testKt3389() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/kt3389.kt"); + } + + @Test + @TestMetadata("kt3584.kt") + public void testKt3584() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/kt3584.kt"); + } + + @Test + @TestMetadata("kt4174.kt") + public void testKt4174() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/kt4174.kt"); + } + + @Test + @TestMetadata("kt45383.kt") + public void testKt45383() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/kt45383.kt"); + } + + @Test + @TestMetadata("localClass.kt") + public void testLocalClass() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/localClass.kt"); + } + + @Test + @TestMetadata("localClassCaptureExtensionReceiver.kt") + public void testLocalClassCaptureExtensionReceiver() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/localClassCaptureExtensionReceiver.kt"); + } + + @Test + @TestMetadata("localClassInInitializer.kt") + public void testLocalClassInInitializer() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/localClassInInitializer.kt"); + } + + @Test + @TestMetadata("localClassInParameterInitializer.kt") + public void testLocalClassInParameterInitializer() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/localClassInParameterInitializer.kt"); + } + + @Test + @TestMetadata("localClassUsedBeforeDeclaration.kt") + public void testLocalClassUsedBeforeDeclaration() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/localClassUsedBeforeDeclaration.kt"); + } + + @Test + @TestMetadata("localDataClass.kt") + public void testLocalDataClass() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/localDataClass.kt"); + } + + @Test + @TestMetadata("localExtendsInnerAndReferencesOuterMember.kt") + public void testLocalExtendsInnerAndReferencesOuterMember() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/localExtendsInnerAndReferencesOuterMember.kt"); + } + + @Test + @TestMetadata("localGenericWithTypeParameters.kt") + public void testLocalGenericWithTypeParameters() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/localGenericWithTypeParameters.kt"); + } + + @Test + @TestMetadata("nameWithWhitespace.kt") + public void testNameWithWhitespace() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/nameWithWhitespace.kt"); + } + + @Test + @TestMetadata("noclosure.kt") + public void testNoclosure() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/noclosure.kt"); + } + + @Test + @TestMetadata("object.kt") + public void testObject() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/object.kt"); + } + + @Test + @TestMetadata("ownClosureOfInnerLocalClass.kt") + public void testOwnClosureOfInnerLocalClass() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/ownClosureOfInnerLocalClass.kt"); + } + + @Test + @TestMetadata("recaptureVarCapturedInLocalClass1.kt") + public void testRecaptureVarCapturedInLocalClass1() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/recaptureVarCapturedInLocalClass1.kt"); + } + + @Test + @TestMetadata("recaptureVarCapturedInLocalClass2.kt") + public void testRecaptureVarCapturedInLocalClass2() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/recaptureVarCapturedInLocalClass2.kt"); + } + + @Test + @TestMetadata("recaptureVarCapturedInLocalClass3.kt") + public void testRecaptureVarCapturedInLocalClass3() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/recaptureVarCapturedInLocalClass3.kt"); + } + + @Test + @TestMetadata("subclassingExtensionReceiverClass.kt") + public void testSubclassingExtensionReceiverClass() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/subclassingExtensionReceiverClass.kt"); + } + + @Test + @TestMetadata("withclosure.kt") + public void testWithclosure() throws Exception { + runTest("compiler/testData/codegen/box/localClasses/withclosure.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/mangling") + @TestDataPath("$PROJECT_ROOT") + public class Mangling { + @Test + public void testAllFilesPresentInMangling() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mangling"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("internal.kt") + public void testInternal() throws Exception { + runTest("compiler/testData/codegen/box/mangling/internal.kt"); + } + + @Test + @TestMetadata("internalOverride.kt") + public void testInternalOverride() throws Exception { + runTest("compiler/testData/codegen/box/mangling/internalOverride.kt"); + } + + @Test + @TestMetadata("internalOverrideSuperCall.kt") + public void testInternalOverrideSuperCall() throws Exception { + runTest("compiler/testData/codegen/box/mangling/internalOverrideSuperCall.kt"); + } + + @Test + @TestMetadata("parentheses.kt") + public void testParentheses() throws Exception { + runTest("compiler/testData/codegen/box/mangling/parentheses.kt"); + } + + @Test + @TestMetadata("publicOverride.kt") + public void testPublicOverride() throws Exception { + runTest("compiler/testData/codegen/box/mangling/publicOverride.kt"); + } + + @Test + @TestMetadata("publicOverrideSuperCall.kt") + public void testPublicOverrideSuperCall() throws Exception { + runTest("compiler/testData/codegen/box/mangling/publicOverrideSuperCall.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/mixedNamedPosition") + @TestDataPath("$PROJECT_ROOT") + public class MixedNamedPosition { + @Test + public void testAllFilesPresentInMixedNamedPosition() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/mixedNamedPosition"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("defaults.kt") + public void testDefaults() throws Exception { + runTest("compiler/testData/codegen/box/mixedNamedPosition/defaults.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/mixedNamedPosition/simple.kt"); + } + + @Test + @TestMetadata("varargs.kt") + public void testVarargs() throws Exception { + runTest("compiler/testData/codegen/box/mixedNamedPosition/varargs.kt"); + } + + @Test + @TestMetadata("varargsEvaluationOrder.kt") + public void testVarargsEvaluationOrder() throws Exception { + runTest("compiler/testData/codegen/box/mixedNamedPosition/varargsEvaluationOrder.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/multiDecl") + @TestDataPath("$PROJECT_ROOT") + public class MultiDecl { + @Test + public void testAllFilesPresentInMultiDecl() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("ComplexInitializer.kt") + public void testComplexInitializer() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/ComplexInitializer.kt"); + } + + @Test + @TestMetadata("component.kt") + public void testComponent() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/component.kt"); + } + + @Test + @TestMetadata("kt9828_hashMap.kt") + public void testKt9828_hashMap() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/kt9828_hashMap.kt"); + } + + @Test + @TestMetadata("returnInElvis.kt") + public void testReturnInElvis() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/returnInElvis.kt"); + } + + @Test + @TestMetadata("SimpleVals.kt") + public void testSimpleVals() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/SimpleVals.kt"); + } + + @Test + @TestMetadata("SimpleValsExtensions.kt") + public void testSimpleValsExtensions() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/SimpleValsExtensions.kt"); + } + + @Test + @TestMetadata("SimpleVarsExtensions.kt") + public void testSimpleVarsExtensions() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/SimpleVarsExtensions.kt"); + } + + @Test + @TestMetadata("UnderscoreNames.kt") + public void testUnderscoreNames() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/UnderscoreNames.kt"); + } + + @Test + @TestMetadata("ValCapturedInFunctionLiteral.kt") + public void testValCapturedInFunctionLiteral() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/ValCapturedInFunctionLiteral.kt"); + } + + @Test + @TestMetadata("ValCapturedInLocalFunction.kt") + public void testValCapturedInLocalFunction() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/ValCapturedInLocalFunction.kt"); + } + + @Test + @TestMetadata("ValCapturedInObjectLiteral.kt") + public void testValCapturedInObjectLiteral() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/ValCapturedInObjectLiteral.kt"); + } + + @Test + @TestMetadata("VarCapturedInFunctionLiteral.kt") + public void testVarCapturedInFunctionLiteral() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/VarCapturedInFunctionLiteral.kt"); + } + + @Test + @TestMetadata("VarCapturedInLocalFunction.kt") + public void testVarCapturedInLocalFunction() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/VarCapturedInLocalFunction.kt"); + } + + @Test + @TestMetadata("VarCapturedInObjectLiteral.kt") + public void testVarCapturedInObjectLiteral() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/VarCapturedInObjectLiteral.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/multiDecl/forIterator") + @TestDataPath("$PROJECT_ROOT") + public class ForIterator { + @Test + public void testAllFilesPresentInForIterator() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("MultiDeclFor.kt") + public void testMultiDeclFor() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forIterator/MultiDeclFor.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentExtensions.kt") + public void testMultiDeclForComponentExtensions() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forIterator/MultiDeclForComponentExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensions.kt") + public void testMultiDeclForComponentMemberExtensions() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forIterator/MultiDeclForComponentMemberExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") + public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forIterator/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); + } + + @Test + @TestMetadata("MultiDeclForValCaptured.kt") + public void testMultiDeclForValCaptured() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forIterator/MultiDeclForValCaptured.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/multiDecl/forIterator/longIterator") + @TestDataPath("$PROJECT_ROOT") + public class LongIterator { + @Test + public void testAllFilesPresentInLongIterator() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forIterator/longIterator"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("MultiDeclForComponentExtensions.kt") + public void testMultiDeclForComponentExtensions() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forIterator/longIterator/MultiDeclForComponentExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentExtensionsValCaptured.kt") + public void testMultiDeclForComponentExtensionsValCaptured() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forIterator/longIterator/MultiDeclForComponentExtensionsValCaptured.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensions.kt") + public void testMultiDeclForComponentMemberExtensions() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forIterator/longIterator/MultiDeclForComponentMemberExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") + public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forIterator/longIterator/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/multiDecl/forRange") + @TestDataPath("$PROJECT_ROOT") + public class ForRange { + @Test + public void testAllFilesPresentInForRange() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("MultiDeclFor.kt") + public void testMultiDeclFor() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/MultiDeclFor.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentExtensions.kt") + public void testMultiDeclForComponentExtensions() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/MultiDeclForComponentExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensions.kt") + public void testMultiDeclForComponentMemberExtensions() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/MultiDeclForComponentMemberExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") + public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); + } + + @Test + @TestMetadata("MultiDeclForValCaptured.kt") + public void testMultiDeclForValCaptured() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/MultiDeclForValCaptured.kt"); + } + + @Test + @TestMetadata("UnderscoreNames.kt") + public void testUnderscoreNames() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/UnderscoreNames.kt"); + } + + @Test + @TestMetadata("UnderscoreNamesDontCallComponent.kt") + public void testUnderscoreNamesDontCallComponent() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/UnderscoreNamesDontCallComponent.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo") + @TestDataPath("$PROJECT_ROOT") + public class ExplicitRangeTo { + @Test + public void testAllFilesPresentInExplicitRangeTo() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("MultiDeclFor.kt") + public void testMultiDeclFor() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/MultiDeclFor.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentExtensions.kt") + public void testMultiDeclForComponentExtensions() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/MultiDeclForComponentExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensions.kt") + public void testMultiDeclForComponentMemberExtensions() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/MultiDeclForComponentMemberExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") + public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); + } + + @Test + @TestMetadata("MultiDeclForValCaptured.kt") + public void testMultiDeclForValCaptured() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/MultiDeclForValCaptured.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int") + @TestDataPath("$PROJECT_ROOT") + public class Int { + @Test + public void testAllFilesPresentInInt() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("MultiDeclForComponentExtensions.kt") + public void testMultiDeclForComponentExtensions() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int/MultiDeclForComponentExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentExtensionsValCaptured.kt") + public void testMultiDeclForComponentExtensionsValCaptured() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int/MultiDeclForComponentExtensionsValCaptured.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensions.kt") + public void testMultiDeclForComponentMemberExtensions() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int/MultiDeclForComponentMemberExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") + public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/int/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long") + @TestDataPath("$PROJECT_ROOT") + public class Long { + @Test + public void testAllFilesPresentInLong() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("MultiDeclForComponentExtensions.kt") + public void testMultiDeclForComponentExtensions() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long/MultiDeclForComponentExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentExtensionsValCaptured.kt") + public void testMultiDeclForComponentExtensionsValCaptured() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long/MultiDeclForComponentExtensionsValCaptured.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensions.kt") + public void testMultiDeclForComponentMemberExtensions() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long/MultiDeclForComponentMemberExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") + public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeTo/long/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot") + @TestDataPath("$PROJECT_ROOT") + public class ExplicitRangeToWithDot { + @Test + public void testAllFilesPresentInExplicitRangeToWithDot() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("MultiDeclFor.kt") + public void testMultiDeclFor() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/MultiDeclFor.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentExtensions.kt") + public void testMultiDeclForComponentExtensions() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/MultiDeclForComponentExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensions.kt") + public void testMultiDeclForComponentMemberExtensions() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/MultiDeclForComponentMemberExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") + public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); + } + + @Test + @TestMetadata("MultiDeclForValCaptured.kt") + public void testMultiDeclForValCaptured() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/MultiDeclForValCaptured.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int") + @TestDataPath("$PROJECT_ROOT") + public class Int { + @Test + public void testAllFilesPresentInInt() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("MultiDeclForComponentExtensions.kt") + public void testMultiDeclForComponentExtensions() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int/MultiDeclForComponentExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentExtensionsValCaptured.kt") + public void testMultiDeclForComponentExtensionsValCaptured() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int/MultiDeclForComponentExtensionsValCaptured.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensions.kt") + public void testMultiDeclForComponentMemberExtensions() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int/MultiDeclForComponentMemberExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") + public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/int/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long") + @TestDataPath("$PROJECT_ROOT") + public class Long { + @Test + public void testAllFilesPresentInLong() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("MultiDeclForComponentExtensions.kt") + public void testMultiDeclForComponentExtensions() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long/MultiDeclForComponentExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentExtensionsValCaptured.kt") + public void testMultiDeclForComponentExtensionsValCaptured() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long/MultiDeclForComponentExtensionsValCaptured.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensions.kt") + public void testMultiDeclForComponentMemberExtensions() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long/MultiDeclForComponentMemberExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") + public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/explicitRangeToWithDot/long/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/multiDecl/forRange/int") + @TestDataPath("$PROJECT_ROOT") + public class Int { + @Test + public void testAllFilesPresentInInt() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/int"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("MultiDeclForComponentExtensions.kt") + public void testMultiDeclForComponentExtensions() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/int/MultiDeclForComponentExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentExtensionsValCaptured.kt") + public void testMultiDeclForComponentExtensionsValCaptured() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/int/MultiDeclForComponentExtensionsValCaptured.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensions.kt") + public void testMultiDeclForComponentMemberExtensions() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/int/MultiDeclForComponentMemberExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") + public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/int/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/multiDecl/forRange/long") + @TestDataPath("$PROJECT_ROOT") + public class Long { + @Test + public void testAllFilesPresentInLong() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiDecl/forRange/long"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("MultiDeclForComponentExtensions.kt") + public void testMultiDeclForComponentExtensions() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/long/MultiDeclForComponentExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentExtensionsValCaptured.kt") + public void testMultiDeclForComponentExtensionsValCaptured() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/long/MultiDeclForComponentExtensionsValCaptured.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensions.kt") + public void testMultiDeclForComponentMemberExtensions() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/long/MultiDeclForComponentMemberExtensions.kt"); + } + + @Test + @TestMetadata("MultiDeclForComponentMemberExtensionsInExtensionFunction.kt") + public void testMultiDeclForComponentMemberExtensionsInExtensionFunction() throws Exception { + runTest("compiler/testData/codegen/box/multiDecl/forRange/long/MultiDeclForComponentMemberExtensionsInExtensionFunction.kt"); + } + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/multifileClasses") + @TestDataPath("$PROJECT_ROOT") + public class MultifileClasses { + @Test + public void testAllFilesPresentInMultifileClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/multifileClasses/optimized") + @TestDataPath("$PROJECT_ROOT") + public class Optimized { + @Test + public void testAllFilesPresentInOptimized() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multifileClasses/optimized"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/multiplatform") + @TestDataPath("$PROJECT_ROOT") + public class Multiplatform { + @Test + public void testAllFilesPresentInMultiplatform() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("expectProperty.kt") + public void testExpectProperty() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/expectProperty.kt"); + } + + @Test + @TestMetadata("optionalExpectation.kt") + public void testOptionalExpectation() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/optionalExpectation.kt"); + } + + @Test + @TestMetadata("starImportOfExpectEnumWithActualTypeAlias.kt") + public void testStarImportOfExpectEnumWithActualTypeAlias() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/starImportOfExpectEnumWithActualTypeAlias.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/multiplatform/defaultArguments") + @TestDataPath("$PROJECT_ROOT") + public class DefaultArguments { + @Test + public void testAllFilesPresentInDefaultArguments() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/defaultArguments"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("bothInExpectAndActual.kt") + public void testBothInExpectAndActual() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/bothInExpectAndActual.kt"); + } + + @Test + @TestMetadata("bothInExpectAndActual2.kt") + public void testBothInExpectAndActual2() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/bothInExpectAndActual2.kt"); + } + + @Test + @TestMetadata("constructor.kt") + public void testConstructor() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/constructor.kt"); + } + + @Test + @TestMetadata("delegatedExpectedInterface.kt") + public void testDelegatedExpectedInterface() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/delegatedExpectedInterface.kt"); + } + + @Test + @TestMetadata("dispatchReceiverValue.kt") + public void testDispatchReceiverValue() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/dispatchReceiverValue.kt"); + } + + @Test + @TestMetadata("extensionReceiverValue.kt") + public void testExtensionReceiverValue() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/extensionReceiverValue.kt"); + } + + @Test + @TestMetadata("function.kt") + public void testFunction() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/function.kt"); + } + + @Test + @TestMetadata("functionFromOtherModule.kt") + public void testFunctionFromOtherModule() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/functionFromOtherModule.kt"); + } + + @Test + @TestMetadata("inheritedFromCommonClass.kt") + public void testInheritedFromCommonClass() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/inheritedFromCommonClass.kt"); + } + + @Test + @TestMetadata("inheritedFromExpectedClass.kt") + public void testInheritedFromExpectedClass() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/inheritedFromExpectedClass.kt"); + } + + @Test + @TestMetadata("inheritedFromExpectedInterface.kt") + public void testInheritedFromExpectedInterface() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/inheritedFromExpectedInterface.kt"); + } + + @Test + @TestMetadata("inheritedFromExpectedMethod.kt") + public void testInheritedFromExpectedMethod() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/inheritedFromExpectedMethod.kt"); + } + + @Test + @TestMetadata("inheritedInExpectedDeclarations.kt") + public void testInheritedInExpectedDeclarations() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/inheritedInExpectedDeclarations.kt"); + } + + @Test + @TestMetadata("inheritedViaAnotherInterfaceIndirectly.kt") + public void testInheritedViaAnotherInterfaceIndirectly() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/inheritedViaAnotherInterfaceIndirectly.kt"); + } + + @Test + @TestMetadata("inlineFunctionWithDefaultLambda.kt") + public void testInlineFunctionWithDefaultLambda() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/inlineFunctionWithDefaultLambda.kt"); + } + + @Test + @TestMetadata("kt23239.kt") + public void testKt23239() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/kt23239.kt"); + } + + @Test + @TestMetadata("kt23739.kt") + public void testKt23739() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/kt23739.kt"); + } + + @Test + @TestMetadata("nestedEnumEntryValue.kt") + public void testNestedEnumEntryValue() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/nestedEnumEntryValue.kt"); + } + + @Test + @TestMetadata("parametersInArgumentValues.kt") + public void testParametersInArgumentValues() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/parametersInArgumentValues.kt"); + } + + @Test + @TestMetadata("superCall.kt") + public void testSuperCall() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/superCall.kt"); + } + + @Test + @TestMetadata("suspend.kt") + public void testSuspend() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/suspend.kt"); + } + + @Test + @TestMetadata("typeAlias.kt") + public void testTypeAlias() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/typeAlias.kt"); + } + + @Test + @TestMetadata("typeAlias2.kt") + public void testTypeAlias2() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/typeAlias2.kt"); + } + + @Test + @TestMetadata("withTypeParameter.kt") + public void testWithTypeParameter() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/defaultArguments/withTypeParameter.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/multiplatform/exhaustiveness") + @TestDataPath("$PROJECT_ROOT") + public class Exhaustiveness { + @Test + public void testAllFilesPresentInExhaustiveness() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/exhaustiveness"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/multiplatform/hmpp") + @TestDataPath("$PROJECT_ROOT") + public class Hmpp { + @Test + public void testAllFilesPresentInHmpp() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/hmpp"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/multiplatform/k2") + @TestDataPath("$PROJECT_ROOT") + public class K2 { + @Test + public void testAllFilesPresentInK2() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/k2"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("anonymousObjectAndSpecificImplementationInDeserializedIr.kt") + public void testAnonymousObjectAndSpecificImplementationInDeserializedIr() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/anonymousObjectAndSpecificImplementationInDeserializedIr.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/multiplatform/k2/annotations") + @TestDataPath("$PROJECT_ROOT") + public class Annotations { + @Test + public void testAllFilesPresentInAnnotations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/k2/annotations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("optionalExpectation.kt") + public void testOptionalExpectation() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/annotations/optionalExpectation.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/multiplatform/k2/basic") + @TestDataPath("$PROJECT_ROOT") + public class Basic { + @Test + @TestMetadata("accessToLocalClassFromBackend.kt") + public void testAccessToLocalClassFromBackend() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/accessToLocalClassFromBackend.kt"); + } + + @Test + public void testAllFilesPresentInBasic() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/k2/basic"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("anyMethodInExpect.kt") + public void testAnyMethodInExpect() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/anyMethodInExpect.kt"); + } + + @Test + @TestMetadata("correctParentForTypeParameter.kt") + public void testCorrectParentForTypeParameter() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/correctParentForTypeParameter.kt"); + } + + @Test + @TestMetadata("enumEntryNameCall.kt") + public void testEnumEntryNameCall() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/enumEntryNameCall.kt"); + } + + @Test + @TestMetadata("expectActualCallableReference.kt") + public void testExpectActualCallableReference() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualCallableReference.kt"); + } + + @Test + @TestMetadata("expectActualDifferentExtensionReceiversOnOverloads.kt") + public void testExpectActualDifferentExtensionReceiversOnOverloads() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualDifferentExtensionReceiversOnOverloads.kt"); + } + + @Test + @TestMetadata("expectActualDifferentPackages.kt") + public void testExpectActualDifferentPackages() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualDifferentPackages.kt"); + } + + @Test + @TestMetadata("expectActualFakeOverrides.kt") + public void testExpectActualFakeOverrides() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualFakeOverrides.kt"); + } + + @Test + @TestMetadata("expectActualFakeOverrides2.kt") + public void testExpectActualFakeOverrides2() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualFakeOverrides2.kt"); + } + + @Test + @TestMetadata("expectActualFakeOverrides3.kt") + public void testExpectActualFakeOverrides3() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualFakeOverrides3.kt"); + } + + @Test + @TestMetadata("expectActualFakeOverridesWithTypeParameters.kt") + public void testExpectActualFakeOverridesWithTypeParameters() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualFakeOverridesWithTypeParameters.kt"); + } + + @Test + @TestMetadata("expectActualFakeOverridesWithTypeParameters2.kt") + public void testExpectActualFakeOverridesWithTypeParameters2() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualFakeOverridesWithTypeParameters2.kt"); + } + + @Test + @TestMetadata("expectActualIntersectionOverride.kt") + public void testExpectActualIntersectionOverride() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualIntersectionOverride.kt"); + } + + @Test + @TestMetadata("expectActualIntersectionOverride2.kt") + public void testExpectActualIntersectionOverride2() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualIntersectionOverride2.kt"); + } + + @Test + @TestMetadata("expectActualMultiCommon.kt") + public void testExpectActualMultiCommon() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualMultiCommon.kt"); + } + + @Test + @TestMetadata("expectActualNullabilityBasedOverloads.kt") + public void testExpectActualNullabilityBasedOverloads() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualNullabilityBasedOverloads.kt"); + } + + @Test + @TestMetadata("expectActualOverloads.kt") + public void testExpectActualOverloads() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualOverloads.kt"); + } + + @Test + @TestMetadata("expectActualSimple.kt") + public void testExpectActualSimple() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualSimple.kt"); + } + + @Test + @TestMetadata("expectActualTypeParameters.kt") + public void testExpectActualTypeParameters() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualTypeParameters.kt"); + } + + @Test + @TestMetadata("expectActualTypealias.kt") + public void testExpectActualTypealias() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectActualTypealias.kt"); + } + + @Test + @TestMetadata("expectInterfaceInSupertypes.kt") + public void testExpectInterfaceInSupertypes() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectInterfaceInSupertypes.kt"); + } + + @Test + @TestMetadata("expectInterfaceInSupertypes2.kt") + public void testExpectInterfaceInSupertypes2() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectInterfaceInSupertypes2.kt"); + } + + @Test + @TestMetadata("expectProperty.kt") + public void testExpectProperty() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/expectProperty.kt"); + } + + @Test + @TestMetadata("fakeOverridesInPlatformModule.kt") + public void testFakeOverridesInPlatformModule() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/fakeOverridesInPlatformModule.kt"); + } + + @Test + @TestMetadata("independentCommonSourceModules.kt") + public void testIndependentCommonSourceModules() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/independentCommonSourceModules.kt"); + } + + @Test + @TestMetadata("interfaceMethodFromSuperTypeIsImplementedInOtherExpectSuperClass.kt") + public void testInterfaceMethodFromSuperTypeIsImplementedInOtherExpectSuperClass() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/interfaceMethodFromSuperTypeIsImplementedInOtherExpectSuperClass.kt"); + } + + @Test + @TestMetadata("kt-56329.kt") + public void testKt_56329() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/kt-56329.kt"); + } + + @Test + @TestMetadata("nonExternalEquals.kt") + public void testNonExternalEquals() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/nonExternalEquals.kt"); + } + + @Test + @TestMetadata("overridesOfExpectMembers.kt") + public void testOverridesOfExpectMembers() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/overridesOfExpectMembers.kt"); + } + + @Test + @TestMetadata("removeExpectDeclarationsFromMetadata.kt") + public void testRemoveExpectDeclarationsFromMetadata() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/removeExpectDeclarationsFromMetadata.kt"); + } + + @Test + @TestMetadata("transitiveSuperclassActualization.kt") + public void testTransitiveSuperclassActualization() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/transitiveSuperclassActualization.kt"); + } + + @Test + @TestMetadata("widerVisibilityInActualClassifier.kt") + public void testWiderVisibilityInActualClassifier() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/basic/widerVisibilityInActualClassifier.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/multiplatform/k2/defaultArguments") + @TestDataPath("$PROJECT_ROOT") + public class DefaultArguments { + @Test + public void testAllFilesPresentInDefaultArguments() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/k2/defaultArguments"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("bothInExpectAndActual.kt") + public void testBothInExpectAndActual() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/bothInExpectAndActual.kt"); + } + + @Test + @TestMetadata("bothInExpectAndActual2.kt") + public void testBothInExpectAndActual2() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/bothInExpectAndActual2.kt"); + } + + @Test + @TestMetadata("constructor.kt") + public void testConstructor() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/constructor.kt"); + } + + @Test + @TestMetadata("delegatedExpectedInterface.kt") + public void testDelegatedExpectedInterface() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/delegatedExpectedInterface.kt"); + } + + @Test + @TestMetadata("dispatchReceiverValue.kt") + public void testDispatchReceiverValue() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/dispatchReceiverValue.kt"); + } + + @Test + @TestMetadata("expectPropertyAsDefaultArgument.kt") + public void testExpectPropertyAsDefaultArgument() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/expectPropertyAsDefaultArgument.kt"); + } + + @Test + @TestMetadata("extensionReceiverValue.kt") + public void testExtensionReceiverValue() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/extensionReceiverValue.kt"); + } + + @Test + @TestMetadata("function.kt") + public void testFunction() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/function.kt"); + } + + @Test + @TestMetadata("functionFromOtherModule.kt") + public void testFunctionFromOtherModule() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/functionFromOtherModule.kt"); + } + + @Test + @TestMetadata("inheritedFromCommonClass.kt") + public void testInheritedFromCommonClass() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/inheritedFromCommonClass.kt"); + } + + @Test + @TestMetadata("inheritedFromExpectedClass.kt") + public void testInheritedFromExpectedClass() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/inheritedFromExpectedClass.kt"); + } + + @Test + @TestMetadata("inheritedFromExpectedInterface.kt") + public void testInheritedFromExpectedInterface() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/inheritedFromExpectedInterface.kt"); + } + + @Test + @TestMetadata("inheritedFromExpectedMethod.kt") + public void testInheritedFromExpectedMethod() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/inheritedFromExpectedMethod.kt"); + } + + @Test + @TestMetadata("inheritedInExpectedDeclarations.kt") + public void testInheritedInExpectedDeclarations() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/inheritedInExpectedDeclarations.kt"); + } + + @Test + @TestMetadata("inheritedViaAnotherInterfaceIndirectly.kt") + public void testInheritedViaAnotherInterfaceIndirectly() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/inheritedViaAnotherInterfaceIndirectly.kt"); + } + + @Test + @TestMetadata("inlineFunctionWithDefaultLambda.kt") + public void testInlineFunctionWithDefaultLambda() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/inlineFunctionWithDefaultLambda.kt"); + } + + @Test + @TestMetadata("kt23239.kt") + public void testKt23239() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/kt23239.kt"); + } + + @Test + @TestMetadata("kt23739.kt") + public void testKt23739() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/kt23739.kt"); + } + + @Test + @TestMetadata("nestedEnumEntryValue.kt") + public void testNestedEnumEntryValue() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/nestedEnumEntryValue.kt"); + } + + @Test + @TestMetadata("parametersInArgumentValues.kt") + public void testParametersInArgumentValues() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/parametersInArgumentValues.kt"); + } + + @Test + @TestMetadata("superCall.kt") + public void testSuperCall() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/superCall.kt"); + } + + @Test + @TestMetadata("suspend.kt") + public void testSuspend() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/suspend.kt"); + } + + @Test + @TestMetadata("typeAlias.kt") + public void testTypeAlias() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/typeAlias.kt"); + } + + @Test + @TestMetadata("withTypeParameter.kt") + public void testWithTypeParameter() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/defaultArguments/withTypeParameter.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/multiplatform/k2/migratedOldTests") + @TestDataPath("$PROJECT_ROOT") + public class MigratedOldTests { + @Test + public void testAllFilesPresentInMigratedOldTests() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/k2/migratedOldTests"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("mpp1.kt") + public void testMpp1() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/migratedOldTests/mpp1.kt"); + } + + @Test + @TestMetadata("mpp2.kt") + public void testMpp2() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/migratedOldTests/mpp2.kt"); + } + + @Test + @TestMetadata("mpp_default_args.kt") + public void testMpp_default_args() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/migratedOldTests/mpp_default_args.kt"); + } + + @Test + @TestMetadata("mpp_optional_expectation.kt") + public void testMpp_optional_expectation() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/migratedOldTests/mpp_optional_expectation.kt"); + } + + @Test + @TestMetadata("remap_expect_property_ref.kt") + public void testRemap_expect_property_ref() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/k2/migratedOldTests/remap_expect_property_ref.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/multiplatform/migratedOldTests") + @TestDataPath("$PROJECT_ROOT") + public class MigratedOldTests { + @Test + public void testAllFilesPresentInMigratedOldTests() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/migratedOldTests"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("mpp1.kt") + public void testMpp1() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/migratedOldTests/mpp1.kt"); + } + + @Test + @TestMetadata("mpp2.kt") + public void testMpp2() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/migratedOldTests/mpp2.kt"); + } + + @Test + @TestMetadata("mpp_default_args.kt") + public void testMpp_default_args() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/migratedOldTests/mpp_default_args.kt"); + } + + @Test + @TestMetadata("remap_expect_property_ref.kt") + public void testRemap_expect_property_ref() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/migratedOldTests/remap_expect_property_ref.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/multiplatform/multiModule") + @TestDataPath("$PROJECT_ROOT") + public class MultiModule { + @Test + public void testAllFilesPresentInMultiModule() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/multiplatform/multiModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("defaultArgument.kt") + public void testDefaultArgument() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/multiModule/defaultArgument.kt"); + } + + @Test + @TestMetadata("expectActualLink.kt") + public void testExpectActualLink() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/multiModule/expectActualLink.kt"); + } + + @Test + @TestMetadata("expectActualMemberLink.kt") + public void testExpectActualMemberLink() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/multiModule/expectActualMemberLink.kt"); + } + + @Test + @TestMetadata("expectActualTypealiasLink.kt") + public void testExpectActualTypealiasLink() throws Exception { + runTest("compiler/testData/codegen/box/multiplatform/multiModule/expectActualTypealiasLink.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/nonLocalReturns") + @TestDataPath("$PROJECT_ROOT") + public class NonLocalReturns { + @Test + public void testAllFilesPresentInNonLocalReturns() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nonLocalReturns"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt9644let.kt") + public void testKt9644let() throws Exception { + runTest("compiler/testData/codegen/box/nonLocalReturns/kt9644let.kt"); + } + + @Test + @TestMetadata("localReturnInsideProperty.kt") + public void testLocalReturnInsideProperty() throws Exception { + runTest("compiler/testData/codegen/box/nonLocalReturns/localReturnInsideProperty.kt"); + } + + @Test + @TestMetadata("returnInsideTwoLambdas.kt") + public void testReturnInsideTwoLambdas() throws Exception { + runTest("compiler/testData/codegen/box/nonLocalReturns/returnInsideTwoLambdas.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/notNullAssertions") + @TestDataPath("$PROJECT_ROOT") + public class NotNullAssertions { + @Test + public void testAllFilesPresentInNotNullAssertions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/notNullAssertions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/nothingValue") + @TestDataPath("$PROJECT_ROOT") + public class NothingValue { + @Test + public void testAllFilesPresentInNothingValue() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nothingValue"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("inNestedCall.kt") + public void testInNestedCall() throws Exception { + runTest("compiler/testData/codegen/box/nothingValue/inNestedCall.kt"); + } + + @Test + @TestMetadata("nothingValueException.kt") + public void testNothingValueException() throws Exception { + runTest("compiler/testData/codegen/box/nothingValue/nothingValueException.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/nullCheckOptimization") + @TestDataPath("$PROJECT_ROOT") + public class NullCheckOptimization { + @Test + public void testAllFilesPresentInNullCheckOptimization() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/nullCheckOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("isNullable.kt") + public void testIsNullable() throws Exception { + runTest("compiler/testData/codegen/box/nullCheckOptimization/isNullable.kt"); + } + + @Test + @TestMetadata("kt22410.kt") + public void testKt22410() throws Exception { + runTest("compiler/testData/codegen/box/nullCheckOptimization/kt22410.kt"); + } + + @Test + @TestMetadata("kt49136a.kt") + public void testKt49136a() throws Exception { + runTest("compiler/testData/codegen/box/nullCheckOptimization/kt49136a.kt"); + } + + @Test + @TestMetadata("kt7774.kt") + public void testKt7774() throws Exception { + runTest("compiler/testData/codegen/box/nullCheckOptimization/kt7774.kt"); + } + + @Test + @TestMetadata("primitiveCheckWithSideEffect.kt") + public void testPrimitiveCheckWithSideEffect() throws Exception { + runTest("compiler/testData/codegen/box/nullCheckOptimization/primitiveCheckWithSideEffect.kt"); + } + + @Test + @TestMetadata("trivialInstanceOf.kt") + public void testTrivialInstanceOf() throws Exception { + runTest("compiler/testData/codegen/box/nullCheckOptimization/trivialInstanceOf.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/objectIntrinsics") + @TestDataPath("$PROJECT_ROOT") + public class ObjectIntrinsics { + @Test + public void testAllFilesPresentInObjectIntrinsics() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objectIntrinsics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("objects.kt") + public void testObjects() throws Exception { + runTest("compiler/testData/codegen/box/objectIntrinsics/objects.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/objects") + @TestDataPath("$PROJECT_ROOT") + public class Objects { + @Test + public void testAllFilesPresentInObjects() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("anonymousObjectAndContrvariantProjection.kt") + public void testAnonymousObjectAndContrvariantProjection() throws Exception { + runTest("compiler/testData/codegen/box/objects/anonymousObjectAndContrvariantProjection.kt"); + } + + @Test + @TestMetadata("anonymousObjectPropertyInitialization.kt") + public void testAnonymousObjectPropertyInitialization() throws Exception { + runTest("compiler/testData/codegen/box/objects/anonymousObjectPropertyInitialization.kt"); + } + + @Test + @TestMetadata("anonymousObjectReturnsFromTopLevelFun.kt") + public void testAnonymousObjectReturnsFromTopLevelFun() throws Exception { + runTest("compiler/testData/codegen/box/objects/anonymousObjectReturnsFromTopLevelFun.kt"); + } + + @Test + @TestMetadata("classCallsProtectedInheritedByCompanion.kt") + public void testClassCallsProtectedInheritedByCompanion() throws Exception { + runTest("compiler/testData/codegen/box/objects/classCallsProtectedInheritedByCompanion.kt"); + } + + @Test + @TestMetadata("classCompanion.kt") + public void testClassCompanion() throws Exception { + runTest("compiler/testData/codegen/box/objects/classCompanion.kt"); + } + + @Test + @TestMetadata("compoundAssignmentToArrayAccessToExtensionPropertyImportedFromObject.kt") + public void testCompoundAssignmentToArrayAccessToExtensionPropertyImportedFromObject() throws Exception { + runTest("compiler/testData/codegen/box/objects/compoundAssignmentToArrayAccessToExtensionPropertyImportedFromObject.kt"); + } + + @Test + @TestMetadata("compoundAssignmentToArrayAccessToPropertyImportedFromObject.kt") + public void testCompoundAssignmentToArrayAccessToPropertyImportedFromObject() throws Exception { + runTest("compiler/testData/codegen/box/objects/compoundAssignmentToArrayAccessToPropertyImportedFromObject.kt"); + } + + @Test + @TestMetadata("compoundAssignmentToExtensionPropertyImportedFromObject.kt") + public void testCompoundAssignmentToExtensionPropertyImportedFromObject() throws Exception { + runTest("compiler/testData/codegen/box/objects/compoundAssignmentToExtensionPropertyImportedFromObject.kt"); + } + + @Test + @TestMetadata("compoundAssignmentToObjectFromCall.kt") + public void testCompoundAssignmentToObjectFromCall() throws Exception { + runTest("compiler/testData/codegen/box/objects/compoundAssignmentToObjectFromCall.kt"); + } + + @Test + @TestMetadata("compoundAssignmentToPropertyImportedFromObject.kt") + public void testCompoundAssignmentToPropertyImportedFromObject() throws Exception { + runTest("compiler/testData/codegen/box/objects/compoundAssignmentToPropertyImportedFromObject.kt"); + } + + @Test + @TestMetadata("compoundAssignmentToPropertyWithQualifier.kt") + public void testCompoundAssignmentToPropertyWithQualifier() throws Exception { + runTest("compiler/testData/codegen/box/objects/compoundAssignmentToPropertyWithQualifier.kt"); + } + + @Test + @TestMetadata("flist.kt") + public void testFlist() throws Exception { + runTest("compiler/testData/codegen/box/objects/flist.kt"); + } + + @Test + @TestMetadata("initializationOrder.kt") + public void testInitializationOrder() throws Exception { + runTest("compiler/testData/codegen/box/objects/initializationOrder.kt"); + } + + @Test + @TestMetadata("initializationOrderConsts.kt") + public void testInitializationOrderConsts() throws Exception { + runTest("compiler/testData/codegen/box/objects/initializationOrderConsts.kt"); + } + + @Test + @TestMetadata("initializerBlockResetToDefault.kt") + public void testInitializerBlockResetToDefault() throws Exception { + runTest("compiler/testData/codegen/box/objects/initializerBlockResetToDefault.kt"); + } + + @Test + @TestMetadata("interfaceCompanion.kt") + public void testInterfaceCompanion() throws Exception { + runTest("compiler/testData/codegen/box/objects/interfaceCompanion.kt"); + } + + @Test + @TestMetadata("interfaceCompanionObjectReference.kt") + public void testInterfaceCompanionObjectReference() throws Exception { + runTest("compiler/testData/codegen/box/objects/interfaceCompanionObjectReference.kt"); + } + + @Test + @TestMetadata("kt1047.kt") + public void testKt1047() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt1047.kt"); + } + + @Test + @TestMetadata("kt11117.kt") + public void testKt11117() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt11117.kt"); + } + + @Test + @TestMetadata("kt1186.kt") + public void testKt1186() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt1186.kt"); + } + + @Test + @TestMetadata("kt1600.kt") + public void testKt1600() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt1600.kt"); + } + + @Test + @TestMetadata("kt1737.kt") + public void testKt1737() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt1737.kt"); + } + + @Test + @TestMetadata("kt18982.kt") + public void testKt18982() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt18982.kt"); + } + + @Test + @TestMetadata("kt2398.kt") + public void testKt2398() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt2398.kt"); + } + + @Test + @TestMetadata("kt2663.kt") + public void testKt2663() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt2663.kt"); + } + + @Test + @TestMetadata("kt2663_2.kt") + public void testKt2663_2() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt2663_2.kt"); + } + + @Test + @TestMetadata("kt2663_3.kt") + public void testKt2663_3() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt2663_3.kt"); + } + + @Test + @TestMetadata("kt2675.kt") + public void testKt2675() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt2675.kt"); + } + + @Test + @TestMetadata("kt2719.kt") + public void testKt2719() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt2719.kt"); + } + + @Test + @TestMetadata("kt2822.kt") + public void testKt2822() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt2822.kt"); + } + + @Test + @TestMetadata("kt32351.kt") + public void testKt32351() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt32351.kt"); + } + + @Test + @TestMetadata("kt3238.kt") + public void testKt3238() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt3238.kt"); + } + + @Test + @TestMetadata("kt32749.kt") + public void testKt32749() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt32749.kt"); + } + + @Test + @TestMetadata("kt3684.kt") + public void testKt3684() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt3684.kt"); + } + + @Test + @TestMetadata("kt4086.kt") + public void testKt4086() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt4086.kt"); + } + + @Test + @TestMetadata("kt45170.kt") + public void testKt45170() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt45170.kt"); + } + + @Test + @TestMetadata("kt46136.kt") + public void testKt46136() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt46136.kt"); + } + + @Test + @TestMetadata("kt52540.kt") + public void testKt52540() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt52540.kt"); + } + + @Test + @TestMetadata("kt535.kt") + public void testKt535() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt535.kt"); + } + + @Test + @TestMetadata("kt694.kt") + public void testKt694() throws Exception { + runTest("compiler/testData/codegen/box/objects/kt694.kt"); + } + + @Test + @TestMetadata("localFunctionInObjectInitializer_kt4516.kt") + public void testLocalFunctionInObjectInitializer_kt4516() throws Exception { + runTest("compiler/testData/codegen/box/objects/localFunctionInObjectInitializer_kt4516.kt"); + } + + @Test + @TestMetadata("methodOnObject.kt") + public void testMethodOnObject() throws Exception { + runTest("compiler/testData/codegen/box/objects/methodOnObject.kt"); + } + + @Test + @TestMetadata("nestedDerivedClassCallsProtectedFromCompanion.kt") + public void testNestedDerivedClassCallsProtectedFromCompanion() throws Exception { + runTest("compiler/testData/codegen/box/objects/nestedDerivedClassCallsProtectedFromCompanion.kt"); + } + + @Test + @TestMetadata("nestedObjectWithSuperclass.kt") + public void testNestedObjectWithSuperclass() throws Exception { + runTest("compiler/testData/codegen/box/objects/nestedObjectWithSuperclass.kt"); + } + + @Test + @TestMetadata("object.kt") + public void testObject() throws Exception { + runTest("compiler/testData/codegen/box/objects/object.kt"); + } + + @Test + @TestMetadata("objectExtendsInnerAndReferencesOuterMember.kt") + public void testObjectExtendsInnerAndReferencesOuterMember() throws Exception { + runTest("compiler/testData/codegen/box/objects/objectExtendsInnerAndReferencesOuterMember.kt"); + } + + @Test + @TestMetadata("objectInLocalAnonymousObject.kt") + public void testObjectInLocalAnonymousObject() throws Exception { + runTest("compiler/testData/codegen/box/objects/objectInLocalAnonymousObject.kt"); + } + + @Test + @TestMetadata("objectInitialization_kt5523.kt") + public void testObjectInitialization_kt5523() throws Exception { + runTest("compiler/testData/codegen/box/objects/objectInitialization_kt5523.kt"); + } + + @Test + @TestMetadata("objectLiteral.kt") + public void testObjectLiteral() throws Exception { + runTest("compiler/testData/codegen/box/objects/objectLiteral.kt"); + } + + @Test + @TestMetadata("objectLiteralInClass.kt") + public void testObjectLiteralInClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/objectLiteralInClass.kt"); + } + + @Test + @TestMetadata("objectLiteralInClosure.kt") + public void testObjectLiteralInClosure() throws Exception { + runTest("compiler/testData/codegen/box/objects/objectLiteralInClosure.kt"); + } + + @Test + @TestMetadata("objectVsClassInitialization_kt5291.kt") + public void testObjectVsClassInitialization_kt5291() throws Exception { + runTest("compiler/testData/codegen/box/objects/objectVsClassInitialization_kt5291.kt"); + } + + @Test + @TestMetadata("objectWithSuperclass.kt") + public void testObjectWithSuperclass() throws Exception { + runTest("compiler/testData/codegen/box/objects/objectWithSuperclass.kt"); + } + + @Test + @TestMetadata("objectWithSuperclassAndTrait.kt") + public void testObjectWithSuperclassAndTrait() throws Exception { + runTest("compiler/testData/codegen/box/objects/objectWithSuperclassAndTrait.kt"); + } + + @Test + @TestMetadata("privateExtensionFromInitializer_kt4543.kt") + public void testPrivateExtensionFromInitializer_kt4543() throws Exception { + runTest("compiler/testData/codegen/box/objects/privateExtensionFromInitializer_kt4543.kt"); + } + + @Test + @TestMetadata("privateFunctionFromClosureInInitializer_kt5582.kt") + public void testPrivateFunctionFromClosureInInitializer_kt5582() throws Exception { + runTest("compiler/testData/codegen/box/objects/privateFunctionFromClosureInInitializer_kt5582.kt"); + } + + @Test + @TestMetadata("receiverInConstructor.kt") + public void testReceiverInConstructor() throws Exception { + runTest("compiler/testData/codegen/box/objects/receiverInConstructor.kt"); + } + + @Test + @TestMetadata("safeAccess.kt") + public void testSafeAccess() throws Exception { + runTest("compiler/testData/codegen/box/objects/safeAccess.kt"); + } + + @Test + @TestMetadata("selfReferenceToCompanionObjectInAnonymousObjectInSuperConstructorCall.kt") + public void testSelfReferenceToCompanionObjectInAnonymousObjectInSuperConstructorCall() throws Exception { + runTest("compiler/testData/codegen/box/objects/selfReferenceToCompanionObjectInAnonymousObjectInSuperConstructorCall.kt"); + } + + @Test + @TestMetadata("selfReferenceToCompanionObjectInInlineLambdaInConstructorBody.kt") + public void testSelfReferenceToCompanionObjectInInlineLambdaInConstructorBody() throws Exception { + runTest("compiler/testData/codegen/box/objects/selfReferenceToCompanionObjectInInlineLambdaInConstructorBody.kt"); + } + + @Test + @TestMetadata("selfReferenceToCompanionObjectInInlineLambdaInSuperConstructorCall.kt") + public void testSelfReferenceToCompanionObjectInInlineLambdaInSuperConstructorCall() throws Exception { + runTest("compiler/testData/codegen/box/objects/selfReferenceToCompanionObjectInInlineLambdaInSuperConstructorCall.kt"); + } + + @Test + @TestMetadata("selfReferenceToCompanionObjectInLambdaInSuperConstructorCall.kt") + public void testSelfReferenceToCompanionObjectInLambdaInSuperConstructorCall() throws Exception { + runTest("compiler/testData/codegen/box/objects/selfReferenceToCompanionObjectInLambdaInSuperConstructorCall.kt"); + } + + @Test + @TestMetadata("selfReferenceToInterfaceCompanionObjectInAnonymousObjectInSuperConstructorCall.kt") + public void testSelfReferenceToInterfaceCompanionObjectInAnonymousObjectInSuperConstructorCall() throws Exception { + runTest("compiler/testData/codegen/box/objects/selfReferenceToInterfaceCompanionObjectInAnonymousObjectInSuperConstructorCall.kt"); + } + + @Test + @TestMetadata("selfReferenceToInterfaceCompanionObjectInInlineLambdaInConstructorBody.kt") + public void testSelfReferenceToInterfaceCompanionObjectInInlineLambdaInConstructorBody() throws Exception { + runTest("compiler/testData/codegen/box/objects/selfReferenceToInterfaceCompanionObjectInInlineLambdaInConstructorBody.kt"); + } + + @Test + @TestMetadata("selfReferenceToInterfaceCompanionObjectInInlineLambdaInSuperConstructorCall.kt") + public void testSelfReferenceToInterfaceCompanionObjectInInlineLambdaInSuperConstructorCall() throws Exception { + runTest("compiler/testData/codegen/box/objects/selfReferenceToInterfaceCompanionObjectInInlineLambdaInSuperConstructorCall.kt"); + } + + @Test + @TestMetadata("selfReferenceToInterfaceCompanionObjectInLambdaInSuperConstructorCall.kt") + public void testSelfReferenceToInterfaceCompanionObjectInLambdaInSuperConstructorCall() throws Exception { + runTest("compiler/testData/codegen/box/objects/selfReferenceToInterfaceCompanionObjectInLambdaInSuperConstructorCall.kt"); + } + + @Test + @TestMetadata("selfReferenceToObjectInAnonymousObjectInSuperConstructorCall.kt") + public void testSelfReferenceToObjectInAnonymousObjectInSuperConstructorCall() throws Exception { + runTest("compiler/testData/codegen/box/objects/selfReferenceToObjectInAnonymousObjectInSuperConstructorCall.kt"); + } + + @Test + @TestMetadata("selfReferenceToObjectInInlineLambdaInConstructorBody.kt") + public void testSelfReferenceToObjectInInlineLambdaInConstructorBody() throws Exception { + runTest("compiler/testData/codegen/box/objects/selfReferenceToObjectInInlineLambdaInConstructorBody.kt"); + } + + @Test + @TestMetadata("selfReferenceToObjectInInlineLambdaInSuperConstructorCall.kt") + public void testSelfReferenceToObjectInInlineLambdaInSuperConstructorCall() throws Exception { + runTest("compiler/testData/codegen/box/objects/selfReferenceToObjectInInlineLambdaInSuperConstructorCall.kt"); + } + + @Test + @TestMetadata("selfReferenceToObjectInLambdaInSuperConstructorCall.kt") + public void testSelfReferenceToObjectInLambdaInSuperConstructorCall() throws Exception { + runTest("compiler/testData/codegen/box/objects/selfReferenceToObjectInLambdaInSuperConstructorCall.kt"); + } + + @Test + @TestMetadata("simpleObject.kt") + public void testSimpleObject() throws Exception { + runTest("compiler/testData/codegen/box/objects/simpleObject.kt"); + } + + @Test + @TestMetadata("substitutionFunctionFromSuper.kt") + public void testSubstitutionFunctionFromSuper() throws Exception { + runTest("compiler/testData/codegen/box/objects/substitutionFunctionFromSuper.kt"); + } + + @Test + @TestMetadata("thisInConstructor.kt") + public void testThisInConstructor() throws Exception { + runTest("compiler/testData/codegen/box/objects/thisInConstructor.kt"); + } + + @Test + @TestMetadata("thisRefToObjectInNestedClassConstructorCall.kt") + public void testThisRefToObjectInNestedClassConstructorCall() throws Exception { + runTest("compiler/testData/codegen/box/objects/thisRefToObjectInNestedClassConstructorCall.kt"); + } + + @Test + @TestMetadata("useAnonymousObjectAsIterator.kt") + public void testUseAnonymousObjectAsIterator() throws Exception { + runTest("compiler/testData/codegen/box/objects/useAnonymousObjectAsIterator.kt"); + } + + @Test + @TestMetadata("useAnonymousObjectFunction.kt") + public void testUseAnonymousObjectFunction() throws Exception { + runTest("compiler/testData/codegen/box/objects/useAnonymousObjectFunction.kt"); + } + + @Test + @TestMetadata("useImportedMember.kt") + public void testUseImportedMember() throws Exception { + runTest("compiler/testData/codegen/box/objects/useImportedMember.kt"); + } + + @Test + @TestMetadata("useImportedMemberFromCompanion.kt") + public void testUseImportedMemberFromCompanion() throws Exception { + runTest("compiler/testData/codegen/box/objects/useImportedMemberFromCompanion.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/objects/companionObjectAccess") + @TestDataPath("$PROJECT_ROOT") + public class CompanionObjectAccess { + @Test + public void testAllFilesPresentInCompanionObjectAccess() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt27117.kt") + public void testKt27117() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/kt27117.kt"); + } + + @Test + @TestMetadata("kt27117_lv12.kt") + public void testKt27117_lv12() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/kt27117_lv12.kt"); + } + + @Test + @TestMetadata("kt27117_lv13.kt") + public void testKt27117_lv13() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/kt27117_lv13.kt"); + } + + @Test + @TestMetadata("kt27121.kt") + public void testKt27121() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/kt27121.kt"); + } + + @Test + @TestMetadata("kt27121_lv12.kt") + public void testKt27121_lv12() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/kt27121_lv12.kt"); + } + + @Test + @TestMetadata("kt27121_lv13.kt") + public void testKt27121_lv13() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/kt27121_lv13.kt"); + } + + @Test + @TestMetadata("privateCompanionObjectAccessedFromAnonymousObjectInNestedClass.kt") + public void testPrivateCompanionObjectAccessedFromAnonymousObjectInNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/privateCompanionObjectAccessedFromAnonymousObjectInNestedClass.kt"); + } + + @Test + @TestMetadata("privateCompanionObjectAccessedFromInitBlock.kt") + public void testPrivateCompanionObjectAccessedFromInitBlock() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/privateCompanionObjectAccessedFromInitBlock.kt"); + } + + @Test + @TestMetadata("privateCompanionObjectAccessedFromInitBlockOfNestedClass.kt") + public void testPrivateCompanionObjectAccessedFromInitBlockOfNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/privateCompanionObjectAccessedFromInitBlockOfNestedClass.kt"); + } + + @Test + @TestMetadata("privateCompanionObjectAccessedFromInlineLambdaInNestedClass.kt") + public void testPrivateCompanionObjectAccessedFromInlineLambdaInNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/privateCompanionObjectAccessedFromInlineLambdaInNestedClass.kt"); + } + + @Test + @TestMetadata("privateCompanionObjectAccessedFromLambdaInNestedClass.kt") + public void testPrivateCompanionObjectAccessedFromLambdaInNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/privateCompanionObjectAccessedFromLambdaInNestedClass.kt"); + } + + @Test + @TestMetadata("privateCompanionObjectAccessedFromMethodInlinedInNestedClass.kt") + public void testPrivateCompanionObjectAccessedFromMethodInlinedInNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/privateCompanionObjectAccessedFromMethodInlinedInNestedClass.kt"); + } + + @Test + @TestMetadata("privateCompanionObjectAccessedFromNestedClass.kt") + public void testPrivateCompanionObjectAccessedFromNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/privateCompanionObjectAccessedFromNestedClass.kt"); + } + + @Test + @TestMetadata("privateCompanionObjectAccessedFromNestedClassSeveralTimes.kt") + public void testPrivateCompanionObjectAccessedFromNestedClassSeveralTimes() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/privateCompanionObjectAccessedFromNestedClassSeveralTimes.kt"); + } + + @Test + @TestMetadata("privateCompanionObjectUsedInNestedClass.kt") + public void testPrivateCompanionObjectUsedInNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/privateCompanionObjectUsedInNestedClass.kt"); + } + + @Test + @TestMetadata("protectedCompanionObjectAccessedFromNestedClass.kt") + public void testProtectedCompanionObjectAccessedFromNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/protectedCompanionObjectAccessedFromNestedClass.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors") + @TestDataPath("$PROJECT_ROOT") + public class MultipleCompanionsWithAccessors { + @Test + @TestMetadata("accessFromInlineLambda.kt") + public void testAccessFromInlineLambda() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/accessFromInlineLambda.kt"); + } + + @Test + public void testAllFilesPresentInMultipleCompanionsWithAccessors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("anonymousObjectInPropertyInitializer.kt") + public void testAnonymousObjectInPropertyInitializer() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/anonymousObjectInPropertyInitializer.kt"); + } + + @Test + @TestMetadata("fromAnonymousObjectInNestedClass.kt") + public void testFromAnonymousObjectInNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromAnonymousObjectInNestedClass.kt"); + } + + @Test + @TestMetadata("fromInitBlock.kt") + public void testFromInitBlock() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInitBlock.kt"); + } + + @Test + @TestMetadata("fromInitBlockOfNestedClass.kt") + public void testFromInitBlockOfNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInitBlockOfNestedClass.kt"); + } + + @Test + @TestMetadata("fromInlineLambdaInNestedClass.kt") + public void testFromInlineLambdaInNestedClass() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromInlineLambdaInNestedClass.kt"); + } + + @Test + @TestMetadata("inheritedProtectedCompanionAndOwnPrivateCompanion.kt") + public void testInheritedProtectedCompanionAndOwnPrivateCompanion() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/inheritedProtectedCompanionAndOwnPrivateCompanion.kt"); + } + + @Test + @TestMetadata("inheritedProtectedCompanionsReferencedByName.kt") + public void testInheritedProtectedCompanionsReferencedByName() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/inheritedProtectedCompanionsReferencedByName.kt"); + } + + @Test + @TestMetadata("lambdaInPropertyInitializer.kt") + public void testLambdaInPropertyInitializer() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/lambdaInPropertyInitializer.kt"); + } + + @Test + @TestMetadata("twoInheritedProtectedCompanions.kt") + public void testTwoInheritedProtectedCompanions() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/twoInheritedProtectedCompanions.kt"); + } + + @Test + @TestMetadata("withCompanionObjectBase.kt") + public void testWithCompanionObjectBase() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/withCompanionObjectBase.kt"); + } + + @Test + @TestMetadata("withMultipleNestedCompanionObjectBases.kt") + public void testWithMultipleNestedCompanionObjectBases() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/withMultipleNestedCompanionObjectBases.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion") + @TestDataPath("$PROJECT_ROOT") + public class PrimitiveCompanion { + @Test + public void testAllFilesPresentInPrimitiveCompanion() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("byteCompanionObject.kt") + public void testByteCompanionObject() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion/byteCompanionObject.kt"); + } + + @Test + @TestMetadata("charCompanionObject.kt") + public void testCharCompanionObject() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion/charCompanionObject.kt"); + } + + @Test + @TestMetadata("doubleCompanionObject.kt") + public void testDoubleCompanionObject() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion/doubleCompanionObject.kt"); + } + + @Test + @TestMetadata("floatCompanionObject.kt") + public void testFloatCompanionObject() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion/floatCompanionObject.kt"); + } + + @Test + @TestMetadata("intCompanionObject.kt") + public void testIntCompanionObject() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion/intCompanionObject.kt"); + } + + @Test + @TestMetadata("longCompanionObject.kt") + public void testLongCompanionObject() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion/longCompanionObject.kt"); + } + + @Test + @TestMetadata("shortCompanionObject.kt") + public void testShortCompanionObject() throws Exception { + runTest("compiler/testData/codegen/box/objects/companionObjectAccess/primitiveCompanion/shortCompanionObject.kt"); + } + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/operatorConventions") + @TestDataPath("$PROJECT_ROOT") + public class OperatorConventions { + @Test + public void testAllFilesPresentInOperatorConventions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("annotatedAssignment.kt") + public void testAnnotatedAssignment() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/annotatedAssignment.kt"); + } + + @Test + @TestMetadata("assignmentOperations.kt") + public void testAssignmentOperations() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/assignmentOperations.kt"); + } + + @Test + @TestMetadata("augmentedAssignmentInInitializer.kt") + public void testAugmentedAssignmentInInitializer() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/augmentedAssignmentInInitializer.kt"); + } + + @Test + @TestMetadata("augmentedAssignmentWithArrayLHS.kt") + public void testAugmentedAssignmentWithArrayLHS() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/augmentedAssignmentWithArrayLHS.kt"); + } + + @Test + @TestMetadata("genericArrayAccessCall.kt") + public void testGenericArrayAccessCall() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/genericArrayAccessCall.kt"); + } + + @Test + @TestMetadata("incDecOnObject.kt") + public void testIncDecOnObject() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/incDecOnObject.kt"); + } + + @Test + @TestMetadata("infixFunctionOverBuiltinMember.kt") + public void testInfixFunctionOverBuiltinMember() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/infixFunctionOverBuiltinMember.kt"); + } + + @Test + @TestMetadata("kt14201.kt") + public void testKt14201() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/kt14201.kt"); + } + + @Test + @TestMetadata("kt14201_2.kt") + public void testKt14201_2() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/kt14201_2.kt"); + } + + @Test + @TestMetadata("kt14227.kt") + public void testKt14227() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/kt14227.kt"); + } + + @Test + @TestMetadata("kt20387.kt") + public void testKt20387() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/kt20387.kt"); + } + + @Test + @TestMetadata("kt39880.kt") + public void testKt39880() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/kt39880.kt"); + } + + @Test + @TestMetadata("kt4152.kt") + public void testKt4152() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/kt4152.kt"); + } + + @Test + @TestMetadata("kt42722.kt") + public void testKt42722() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/kt42722.kt"); + } + + @Test + @TestMetadata("kt44647.kt") + public void testKt44647() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/kt44647.kt"); + } + + @Test + @TestMetadata("kt45022.kt") + public void testKt45022() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/kt45022.kt"); + } + + @Test + @TestMetadata("kt4987.kt") + public void testKt4987() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/kt4987.kt"); + } + + @Test + @TestMetadata("nestedMaps.kt") + public void testNestedMaps() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/nestedMaps.kt"); + } + + @Test + @TestMetadata("operatorSetLambda.kt") + public void testOperatorSetLambda() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/operatorSetLambda.kt"); + } + + @Test + @TestMetadata("overloadedSet.kt") + public void testOverloadedSet() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/overloadedSet.kt"); + } + + @Test + @TestMetadata("plusAssignWithComplexRHS.kt") + public void testPlusAssignWithComplexRHS() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/plusAssignWithComplexRHS.kt"); + } + + @Test + @TestMetadata("plusExplicit.kt") + public void testPlusExplicit() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/plusExplicit.kt"); + } + + @Test + @TestMetadata("remAssignmentOperation.kt") + public void testRemAssignmentOperation() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/remAssignmentOperation.kt"); + } + + @Test + @TestMetadata("remOverModOperation.kt") + public void testRemOverModOperation() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/remOverModOperation.kt"); + } + + @Test + @TestMetadata("suspendOperators.kt") + public void testSuspendOperators() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/suspendOperators.kt"); + } + + @Test + @TestMetadata("untilOperator.kt") + public void testUntilOperator() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/untilOperator.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/operatorConventions/compareTo") + @TestDataPath("$PROJECT_ROOT") + public class CompareTo { + @Test + public void testAllFilesPresentInCompareTo() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/operatorConventions/compareTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("boolean.kt") + public void testBoolean() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/compareTo/boolean.kt"); + } + + @Test + @TestMetadata("comparable.kt") + public void testComparable() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/compareTo/comparable.kt"); + } + + @Test + @TestMetadata("customCompareTo.kt") + public void testCustomCompareTo() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/compareTo/customCompareTo.kt"); + } + + @Test + @TestMetadata("doubleInt.kt") + public void testDoubleInt() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/compareTo/doubleInt.kt"); + } + + @Test + @TestMetadata("doubleLong.kt") + public void testDoubleLong() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/compareTo/doubleLong.kt"); + } + + @Test + @TestMetadata("extensionArray.kt") + public void testExtensionArray() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/compareTo/extensionArray.kt"); + } + + @Test + @TestMetadata("extensionObject.kt") + public void testExtensionObject() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/compareTo/extensionObject.kt"); + } + + @Test + @TestMetadata("intDouble.kt") + public void testIntDouble() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/compareTo/intDouble.kt"); + } + + @Test + @TestMetadata("intLong.kt") + public void testIntLong() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/compareTo/intLong.kt"); + } + + @Test + @TestMetadata("longDouble.kt") + public void testLongDouble() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/compareTo/longDouble.kt"); + } + + @Test + @TestMetadata("longInt.kt") + public void testLongInt() throws Exception { + runTest("compiler/testData/codegen/box/operatorConventions/compareTo/longInt.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/optimizations") + @TestDataPath("$PROJECT_ROOT") + public class Optimizations { + @Test + public void testAllFilesPresentInOptimizations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/optimizations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt20844.kt") + public void testKt20844() throws Exception { + runTest("compiler/testData/codegen/box/optimizations/kt20844.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/package") + @TestDataPath("$PROJECT_ROOT") + public class Package { + @Test + public void testAllFilesPresentInPackage() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/package"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("boxPrimitiveTypeInClinit.kt") + public void testBoxPrimitiveTypeInClinit() throws Exception { + runTest("compiler/testData/codegen/box/package/boxPrimitiveTypeInClinit.kt"); + } + + @Test + @TestMetadata("checkCast.kt") + public void testCheckCast() throws Exception { + runTest("compiler/testData/codegen/box/package/checkCast.kt"); + } + + @Test + @TestMetadata("incrementProperty.kt") + public void testIncrementProperty() throws Exception { + runTest("compiler/testData/codegen/box/package/incrementProperty.kt"); + } + + @Test + @TestMetadata("initializationOrder.kt") + public void testInitializationOrder() throws Exception { + runTest("compiler/testData/codegen/box/package/initializationOrder.kt"); + } + + @Test + @TestMetadata("invokespecial.kt") + public void testInvokespecial() throws Exception { + runTest("compiler/testData/codegen/box/package/invokespecial.kt"); + } + + @Test + @TestMetadata("kt57353.kt") + public void testKt57353() throws Exception { + runTest("compiler/testData/codegen/box/package/kt57353.kt"); + } + + @Test + @TestMetadata("nullablePrimitiveNoFieldInitializer.kt") + public void testNullablePrimitiveNoFieldInitializer() throws Exception { + runTest("compiler/testData/codegen/box/package/nullablePrimitiveNoFieldInitializer.kt"); + } + + @Test + @TestMetadata("packageLocalClassNotImportedWithDefaultImport.kt") + public void testPackageLocalClassNotImportedWithDefaultImport() throws Exception { + runTest("compiler/testData/codegen/box/package/packageLocalClassNotImportedWithDefaultImport.kt"); + } + + @Test + @TestMetadata("packageQualifiedMethod.kt") + public void testPackageQualifiedMethod() throws Exception { + runTest("compiler/testData/codegen/box/package/packageQualifiedMethod.kt"); + } + + @Test + @TestMetadata("privateMembersInImportList.kt") + public void testPrivateMembersInImportList() throws Exception { + runTest("compiler/testData/codegen/box/package/privateMembersInImportList.kt"); + } + + @Test + @TestMetadata("privateTopLevelPropAndVarInInner.kt") + public void testPrivateTopLevelPropAndVarInInner() throws Exception { + runTest("compiler/testData/codegen/box/package/privateTopLevelPropAndVarInInner.kt"); + } + + @Test + @TestMetadata("referenceWithTheSameNameAsPackage.kt") + public void testReferenceWithTheSameNameAsPackage() throws Exception { + runTest("compiler/testData/codegen/box/package/referenceWithTheSameNameAsPackage.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/parametersMetadata") + @TestDataPath("$PROJECT_ROOT") + public class ParametersMetadata { + @Test + public void testAllFilesPresentInParametersMetadata() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/parametersMetadata"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/platformTypes") + @TestDataPath("$PROJECT_ROOT") + public class PlatformTypes { + @Test + public void testAllFilesPresentInPlatformTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/platformTypes/primitives") + @TestDataPath("$PROJECT_ROOT") + public class Primitives { + @Test + public void testAllFilesPresentInPrimitives() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/platformTypes/primitives"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("assign.kt") + public void testAssign() throws Exception { + runTest("compiler/testData/codegen/box/platformTypes/primitives/assign.kt"); + } + + @Test + @TestMetadata("compareTo.kt") + public void testCompareTo() throws Exception { + runTest("compiler/testData/codegen/box/platformTypes/primitives/compareTo.kt"); + } + + @Test + @TestMetadata("dec.kt") + public void testDec() throws Exception { + runTest("compiler/testData/codegen/box/platformTypes/primitives/dec.kt"); + } + + @Test + @TestMetadata("div.kt") + public void testDiv() throws Exception { + runTest("compiler/testData/codegen/box/platformTypes/primitives/div.kt"); + } + + @Test + @TestMetadata("equals.kt") + public void testEquals() throws Exception { + runTest("compiler/testData/codegen/box/platformTypes/primitives/equals.kt"); + } + + @Test + @TestMetadata("hashCode.kt") + public void testHashCode() throws Exception { + runTest("compiler/testData/codegen/box/platformTypes/primitives/hashCode.kt"); + } + + @Test + @TestMetadata("inc.kt") + public void testInc() throws Exception { + runTest("compiler/testData/codegen/box/platformTypes/primitives/inc.kt"); + } + + @Test + @TestMetadata("minus.kt") + public void testMinus() throws Exception { + runTest("compiler/testData/codegen/box/platformTypes/primitives/minus.kt"); + } + + @Test + @TestMetadata("mod.kt") + public void testMod() throws Exception { + runTest("compiler/testData/codegen/box/platformTypes/primitives/mod.kt"); + } + + @Test + @TestMetadata("not.kt") + public void testNot() throws Exception { + runTest("compiler/testData/codegen/box/platformTypes/primitives/not.kt"); + } + + @Test + @TestMetadata("notEquals.kt") + public void testNotEquals() throws Exception { + runTest("compiler/testData/codegen/box/platformTypes/primitives/notEquals.kt"); + } + + @Test + @TestMetadata("plus.kt") + public void testPlus() throws Exception { + runTest("compiler/testData/codegen/box/platformTypes/primitives/plus.kt"); + } + + @Test + @TestMetadata("plusAssign.kt") + public void testPlusAssign() throws Exception { + runTest("compiler/testData/codegen/box/platformTypes/primitives/plusAssign.kt"); + } + + @Test + @TestMetadata("rangeTo.kt") + public void testRangeTo() throws Exception { + runTest("compiler/testData/codegen/box/platformTypes/primitives/rangeTo.kt"); + } + + @Test + @TestMetadata("times.kt") + public void testTimes() throws Exception { + runTest("compiler/testData/codegen/box/platformTypes/primitives/times.kt"); + } + + @Test + @TestMetadata("toShort.kt") + public void testToShort() throws Exception { + runTest("compiler/testData/codegen/box/platformTypes/primitives/toShort.kt"); + } + + @Test + @TestMetadata("toString.kt") + public void testToString() throws Exception { + runTest("compiler/testData/codegen/box/platformTypes/primitives/toString.kt"); + } + + @Test + @TestMetadata("unaryMinus.kt") + public void testUnaryMinus() throws Exception { + runTest("compiler/testData/codegen/box/platformTypes/primitives/unaryMinus.kt"); + } + + @Test + @TestMetadata("unaryPlus.kt") + public void testUnaryPlus() throws Exception { + runTest("compiler/testData/codegen/box/platformTypes/primitives/unaryPlus.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/polymorphicSignature") + @TestDataPath("$PROJECT_ROOT") + public class PolymorphicSignature { + @Test + public void testAllFilesPresentInPolymorphicSignature() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/polymorphicSignature"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/primitiveTypes") + @TestDataPath("$PROJECT_ROOT") + public class PrimitiveTypes { + @Test + public void testAllFilesPresentInPrimitiveTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("booleanHashCode.kt") + public void testBooleanHashCode() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/booleanHashCode.kt"); + } + + @Test + @TestMetadata("comparisonWithNullCallsFun.kt") + public void testComparisonWithNullCallsFun() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/comparisonWithNullCallsFun.kt"); + } + + @Test + @TestMetadata("conversions.kt") + public void testConversions() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/conversions.kt"); + } + + @Test + @TestMetadata("ea35963.kt") + public void testEa35963() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/ea35963.kt"); + } + + @Test + @TestMetadata("equalsHashCodeToString.kt") + public void testEqualsHashCodeToString() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalsHashCodeToString.kt"); + } + + @Test + @TestMetadata("incrementByteCharShort.kt") + public void testIncrementByteCharShort() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/incrementByteCharShort.kt"); + } + + @Test + @TestMetadata("intLiteralIsNotNull.kt") + public void testIntLiteralIsNotNull() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/intLiteralIsNotNull.kt"); + } + + @Test + @TestMetadata("kt1054.kt") + public void testKt1054() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt1054.kt"); + } + + @Test + @TestMetadata("kt1055.kt") + public void testKt1055() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt1055.kt"); + } + + @Test + @TestMetadata("kt1093.kt") + public void testKt1093() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt1093.kt"); + } + + @Test + @TestMetadata("kt13023.kt") + public void testKt13023() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt13023.kt"); + } + + @Test + @TestMetadata("kt14868.kt") + public void testKt14868() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt14868.kt"); + } + + @Test + @TestMetadata("kt1508.kt") + public void testKt1508() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt1508.kt"); + } + + @Test + @TestMetadata("kt1634.kt") + public void testKt1634() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt1634.kt"); + } + + @Test + @TestMetadata("kt16732.kt") + public void testKt16732() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt16732.kt"); + } + + @Test + @TestMetadata("kt2251.kt") + public void testKt2251() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt2251.kt"); + } + + @Test + @TestMetadata("kt2269.kt") + public void testKt2269() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt2269.kt"); + } + + @Test + @TestMetadata("kt2269NotOptimizable.kt") + public void testKt2269NotOptimizable() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt2269NotOptimizable.kt"); + } + + @Test + @TestMetadata("kt2275.kt") + public void testKt2275() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt2275.kt"); + } + + @Test + @TestMetadata("kt239.kt") + public void testKt239() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt239.kt"); + } + + @Test + @TestMetadata("kt242.kt") + public void testKt242() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt242.kt"); + } + + @Test + @TestMetadata("kt248.kt") + public void testKt248() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt248.kt"); + } + + @Test + @TestMetadata("kt2768.kt") + public void testKt2768() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt2768.kt"); + } + + @Test + @TestMetadata("kt2794.kt") + public void testKt2794() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt2794.kt"); + } + + @Test + @TestMetadata("kt3078.kt") + public void testKt3078() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt3078.kt"); + } + + @Test + @TestMetadata("kt3517.kt") + public void testKt3517() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt3517.kt"); + } + + @Test + @TestMetadata("kt3576.kt") + public void testKt3576() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt3576.kt"); + } + + @Test + @TestMetadata("kt3613.kt") + public void testKt3613() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt3613.kt"); + } + + @Test + @TestMetadata("kt36952_identityEqualsWithBooleanInLocalFunction.kt") + public void testKt36952_identityEqualsWithBooleanInLocalFunction() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt36952_identityEqualsWithBooleanInLocalFunction.kt"); + } + + @Test + @TestMetadata("kt37505.kt") + public void testKt37505() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt37505.kt"); + } + + @Test + @TestMetadata("kt4097.kt") + public void testKt4097() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt4097.kt"); + } + + @Test + @TestMetadata("kt4098.kt") + public void testKt4098() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt4098.kt"); + } + + @Test + @TestMetadata("kt4210.kt") + public void testKt4210() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt4210.kt"); + } + + @Test + @TestMetadata("kt4251.kt") + public void testKt4251() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt4251.kt"); + } + + @Test + @TestMetadata("kt446.kt") + public void testKt446() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt446.kt"); + } + + @Test + @TestMetadata("kt46864_double.kt") + public void testKt46864_double() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt46864_double.kt"); + } + + @Test + @TestMetadata("kt46864_long.kt") + public void testKt46864_long() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt46864_long.kt"); + } + + @Test + @TestMetadata("kt518.kt") + public void testKt518() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt518.kt"); + } + + @Test + @TestMetadata("kt6590_identityEquals.kt") + public void testKt6590_identityEquals() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt6590_identityEquals.kt"); + } + + @Test + @TestMetadata("kt665.kt") + public void testKt665() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt665.kt"); + } + + @Test + @TestMetadata("kt684.kt") + public void testKt684() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt684.kt"); + } + + @Test + @TestMetadata("kt711.kt") + public void testKt711() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt711.kt"); + } + + @Test + @TestMetadata("kt737.kt") + public void testKt737() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt737.kt"); + } + + @Test + @TestMetadata("kt752.kt") + public void testKt752() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt752.kt"); + } + + @Test + @TestMetadata("kt753.kt") + public void testKt753() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt753.kt"); + } + + @Test + @TestMetadata("kt756.kt") + public void testKt756() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt756.kt"); + } + + @Test + @TestMetadata("kt757.kt") + public void testKt757() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt757.kt"); + } + + @Test + @TestMetadata("kt828.kt") + public void testKt828() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt828.kt"); + } + + @Test + @TestMetadata("kt877.kt") + public void testKt877() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt877.kt"); + } + + @Test + @TestMetadata("kt882.kt") + public void testKt882() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt882.kt"); + } + + @Test + @TestMetadata("kt887.kt") + public void testKt887() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt887.kt"); + } + + @Test + @TestMetadata("kt935.kt") + public void testKt935() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/kt935.kt"); + } + + @Test + @TestMetadata("nullAsNullableIntIsNull.kt") + public void testNullAsNullableIntIsNull() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/nullAsNullableIntIsNull.kt"); + } + + @Test + @TestMetadata("nullableAsIndex.kt") + public void testNullableAsIndex() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/nullableAsIndex.kt"); + } + + @Test + @TestMetadata("nullableCharBoolean.kt") + public void testNullableCharBoolean() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/nullableCharBoolean.kt"); + } + + @Test + @TestMetadata("numberEqualsHashCodeToString.kt") + public void testNumberEqualsHashCodeToString() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/numberEqualsHashCodeToString.kt"); + } + + @Test + @TestMetadata("rangeTo.kt") + public void testRangeTo() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/rangeTo.kt"); + } + + @Test + @TestMetadata("stringEqualsHashCodeToString.kt") + public void testStringEqualsHashCodeToString() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/stringEqualsHashCodeToString.kt"); + } + + @Test + @TestMetadata("substituteIntForGeneric.kt") + public void testSubstituteIntForGeneric() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/substituteIntForGeneric.kt"); + } + + @Test + @TestMetadata("unboxComparable.kt") + public void testUnboxComparable() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/unboxComparable.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/primitiveTypes/equalityWithObject") + @TestDataPath("$PROJECT_ROOT") + public class EqualityWithObject { + @Test + public void testAllFilesPresentInEqualityWithObject() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("boxedEqPrimitiveEvaluationOrder.kt") + public void testBoxedEqPrimitiveEvaluationOrder() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/boxedEqPrimitiveEvaluationOrder.kt"); + } + + @Test + @TestMetadata("boxedLongEqualsLong.kt") + public void testBoxedLongEqualsLong() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/boxedLongEqualsLong.kt"); + } + + @Test + @TestMetadata("intEqualsNull.kt") + public void testIntEqualsNull() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/intEqualsNull.kt"); + } + + @Test + @TestMetadata("intEqualsNullableInt.kt") + public void testIntEqualsNullableInt() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/intEqualsNullableInt.kt"); + } + + @Test + @TestMetadata("intEqualsNullableIntWithSmartCasts.kt") + public void testIntEqualsNullableIntWithSmartCasts() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/intEqualsNullableIntWithSmartCasts.kt"); + } + + @Test + @TestMetadata("kt42281.kt") + public void testKt42281() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/kt42281.kt"); + } + + @Test + @TestMetadata("objectWithAsymmetricEqualsEqPrimitive.kt") + public void testObjectWithAsymmetricEqualsEqPrimitive() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/objectWithAsymmetricEqualsEqPrimitive.kt"); + } + + @Test + @TestMetadata("whenIntAsNullableAny.kt") + public void testWhenIntAsNullableAny() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/whenIntAsNullableAny.kt"); + } + + @Test + @TestMetadata("whenNullableBoxed.kt") + public void testWhenNullableBoxed() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/whenNullableBoxed.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated") + @TestDataPath("$PROJECT_ROOT") + public class Generated { + @Test + public void testAllFilesPresentInGenerated() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("boxedEqPrimitiveBoolean.kt") + public void testBoxedEqPrimitiveBoolean() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/boxedEqPrimitiveBoolean.kt"); + } + + @Test + @TestMetadata("boxedEqPrimitiveByte.kt") + public void testBoxedEqPrimitiveByte() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/boxedEqPrimitiveByte.kt"); + } + + @Test + @TestMetadata("boxedEqPrimitiveChar.kt") + public void testBoxedEqPrimitiveChar() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/boxedEqPrimitiveChar.kt"); + } + + @Test + @TestMetadata("boxedEqPrimitiveInt.kt") + public void testBoxedEqPrimitiveInt() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/boxedEqPrimitiveInt.kt"); + } + + @Test + @TestMetadata("boxedEqPrimitiveLong.kt") + public void testBoxedEqPrimitiveLong() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/boxedEqPrimitiveLong.kt"); + } + + @Test + @TestMetadata("boxedEqPrimitiveShort.kt") + public void testBoxedEqPrimitiveShort() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/boxedEqPrimitiveShort.kt"); + } + + @Test + @TestMetadata("primitiveEqBoxedBoolean.kt") + public void testPrimitiveEqBoxedBoolean() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/primitiveEqBoxedBoolean.kt"); + } + + @Test + @TestMetadata("primitiveEqBoxedByte.kt") + public void testPrimitiveEqBoxedByte() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/primitiveEqBoxedByte.kt"); + } + + @Test + @TestMetadata("primitiveEqBoxedChar.kt") + public void testPrimitiveEqBoxedChar() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/primitiveEqBoxedChar.kt"); + } + + @Test + @TestMetadata("primitiveEqBoxedInt.kt") + public void testPrimitiveEqBoxedInt() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/primitiveEqBoxedInt.kt"); + } + + @Test + @TestMetadata("primitiveEqBoxedLong.kt") + public void testPrimitiveEqBoxedLong() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/primitiveEqBoxedLong.kt"); + } + + @Test + @TestMetadata("primitiveEqBoxedShort.kt") + public void testPrimitiveEqBoxedShort() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/primitiveEqBoxedShort.kt"); + } + + @Test + @TestMetadata("primitiveEqObjectBoolean.kt") + public void testPrimitiveEqObjectBoolean() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/primitiveEqObjectBoolean.kt"); + } + + @Test + @TestMetadata("primitiveEqObjectByte.kt") + public void testPrimitiveEqObjectByte() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/primitiveEqObjectByte.kt"); + } + + @Test + @TestMetadata("primitiveEqObjectChar.kt") + public void testPrimitiveEqObjectChar() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/primitiveEqObjectChar.kt"); + } + + @Test + @TestMetadata("primitiveEqObjectInt.kt") + public void testPrimitiveEqObjectInt() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/primitiveEqObjectInt.kt"); + } + + @Test + @TestMetadata("primitiveEqObjectLong.kt") + public void testPrimitiveEqObjectLong() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/primitiveEqObjectLong.kt"); + } + + @Test + @TestMetadata("primitiveEqObjectShort.kt") + public void testPrimitiveEqObjectShort() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/equalityWithObject/generated/primitiveEqObjectShort.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/primitiveTypes/numberToChar") + @TestDataPath("$PROJECT_ROOT") + public class NumberToChar { + @Test + @TestMetadata("abstractMethodInSuperinterface.kt") + public void testAbstractMethodInSuperinterface() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/numberToChar/abstractMethodInSuperinterface.kt"); + } + + @Test + public void testAllFilesPresentInNumberToChar() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/primitiveTypes/numberToChar"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("fakeOverride.kt") + public void testFakeOverride() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/numberToChar/fakeOverride.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/numberToChar/simple.kt"); + } + + @Test + @TestMetadata("superCallToClass.kt") + public void testSuperCallToClass() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/numberToChar/superCallToClass.kt"); + } + + @Test + @TestMetadata("superCallToInterface.kt") + public void testSuperCallToInterface() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/numberToChar/superCallToInterface.kt"); + } + + @Test + @TestMetadata("superCallToNumber.kt") + public void testSuperCallToNumber() throws Exception { + runTest("compiler/testData/codegen/box/primitiveTypes/numberToChar/superCallToNumber.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/private") + @TestDataPath("$PROJECT_ROOT") + public class Private { + @Test + public void testAllFilesPresentInPrivate() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/private"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("arrayConvention.kt") + public void testArrayConvention() throws Exception { + runTest("compiler/testData/codegen/box/private/arrayConvention.kt"); + } + + @Test + @TestMetadata("kt9855.kt") + public void testKt9855() throws Exception { + runTest("compiler/testData/codegen/box/private/kt9855.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/privateConstructors") + @TestDataPath("$PROJECT_ROOT") + public class PrivateConstructors { + @Test + public void testAllFilesPresentInPrivateConstructors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/privateConstructors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("base.kt") + public void testBase() throws Exception { + runTest("compiler/testData/codegen/box/privateConstructors/base.kt"); + } + + @Test + @TestMetadata("captured.kt") + public void testCaptured() throws Exception { + runTest("compiler/testData/codegen/box/privateConstructors/captured.kt"); + } + + @Test + @TestMetadata("companion.kt") + public void testCompanion() throws Exception { + runTest("compiler/testData/codegen/box/privateConstructors/companion.kt"); + } + + @Test + @TestMetadata("inline.kt") + public void testInline() throws Exception { + runTest("compiler/testData/codegen/box/privateConstructors/inline.kt"); + } + + @Test + @TestMetadata("inner.kt") + public void testInner() throws Exception { + runTest("compiler/testData/codegen/box/privateConstructors/inner.kt"); + } + + @Test + @TestMetadata("kt4860.kt") + public void testKt4860() throws Exception { + runTest("compiler/testData/codegen/box/privateConstructors/kt4860.kt"); + } + + @Test + @TestMetadata("secondary.kt") + public void testSecondary() throws Exception { + runTest("compiler/testData/codegen/box/privateConstructors/secondary.kt"); + } + + @Test + @TestMetadata("withArguments.kt") + public void testWithArguments() throws Exception { + runTest("compiler/testData/codegen/box/privateConstructors/withArguments.kt"); + } + + @Test + @TestMetadata("withDefault.kt") + public void testWithDefault() throws Exception { + runTest("compiler/testData/codegen/box/privateConstructors/withDefault.kt"); + } + + @Test + @TestMetadata("withLinkedClasses.kt") + public void testWithLinkedClasses() throws Exception { + runTest("compiler/testData/codegen/box/privateConstructors/withLinkedClasses.kt"); + } + + @Test + @TestMetadata("withLinkedObjects.kt") + public void testWithLinkedObjects() throws Exception { + runTest("compiler/testData/codegen/box/privateConstructors/withLinkedObjects.kt"); + } + + @Test + @TestMetadata("withVarargs.kt") + public void testWithVarargs() throws Exception { + runTest("compiler/testData/codegen/box/privateConstructors/withVarargs.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/properties") + @TestDataPath("$PROJECT_ROOT") + public class Properties { + @Test + @TestMetadata("accessToPrivateProperty.kt") + public void testAccessToPrivateProperty() throws Exception { + runTest("compiler/testData/codegen/box/properties/accessToPrivateProperty.kt"); + } + + @Test + @TestMetadata("accessToPrivateSetter.kt") + public void testAccessToPrivateSetter() throws Exception { + runTest("compiler/testData/codegen/box/properties/accessToPrivateSetter.kt"); + } + + @Test + @TestMetadata("accessorForProtectedPropertyWithPrivateSetter.kt") + public void testAccessorForProtectedPropertyWithPrivateSetter() throws Exception { + runTest("compiler/testData/codegen/box/properties/accessorForProtectedPropertyWithPrivateSetter.kt"); + } + + @Test + @TestMetadata("accessorForProtectedPropertyWithPrivateSetterInObjectLiteral.kt") + public void testAccessorForProtectedPropertyWithPrivateSetterInObjectLiteral() throws Exception { + runTest("compiler/testData/codegen/box/properties/accessorForProtectedPropertyWithPrivateSetterInObjectLiteral.kt"); + } + + @Test + @TestMetadata("accessorForProtectedPropertyWithPrivateSetterViaSuper.kt") + public void testAccessorForProtectedPropertyWithPrivateSetterViaSuper() throws Exception { + runTest("compiler/testData/codegen/box/properties/accessorForProtectedPropertyWithPrivateSetterViaSuper.kt"); + } + + @Test + @TestMetadata("accessorForProtectedPropertyWithPrivateSetterWithIntermediateClass.kt") + public void testAccessorForProtectedPropertyWithPrivateSetterWithIntermediateClass() throws Exception { + runTest("compiler/testData/codegen/box/properties/accessorForProtectedPropertyWithPrivateSetterWithIntermediateClass.kt"); + } + + @Test + public void testAllFilesPresentInProperties() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("augmentedAssignmentsAndIncrements.kt") + public void testAugmentedAssignmentsAndIncrements() throws Exception { + runTest("compiler/testData/codegen/box/properties/augmentedAssignmentsAndIncrements.kt"); + } + + @Test + @TestMetadata("classArtificialFieldInsideNested.kt") + public void testClassArtificialFieldInsideNested() throws Exception { + runTest("compiler/testData/codegen/box/properties/classArtificialFieldInsideNested.kt"); + } + + @Test + @TestMetadata("classFieldInsideLambda.kt") + public void testClassFieldInsideLambda() throws Exception { + runTest("compiler/testData/codegen/box/properties/classFieldInsideLambda.kt"); + } + + @Test + @TestMetadata("classFieldInsideLocalInSetter.kt") + public void testClassFieldInsideLocalInSetter() throws Exception { + runTest("compiler/testData/codegen/box/properties/classFieldInsideLocalInSetter.kt"); + } + + @Test + @TestMetadata("classFieldInsideNested.kt") + public void testClassFieldInsideNested() throws Exception { + runTest("compiler/testData/codegen/box/properties/classFieldInsideNested.kt"); + } + + @Test + @TestMetadata("classFieldInsideNestedLambda.kt") + public void testClassFieldInsideNestedLambda() throws Exception { + runTest("compiler/testData/codegen/box/properties/classFieldInsideNestedLambda.kt"); + } + + @Test + @TestMetadata("classFieldInsideNestedNestedLambda.kt") + public void testClassFieldInsideNestedNestedLambda() throws Exception { + runTest("compiler/testData/codegen/box/properties/classFieldInsideNestedNestedLambda.kt"); + } + + @Test + @TestMetadata("classObjectProperties.kt") + public void testClassObjectProperties() throws Exception { + runTest("compiler/testData/codegen/box/properties/classObjectProperties.kt"); + } + + @Test + @TestMetadata("classPrivateArtificialFieldInsideNested.kt") + public void testClassPrivateArtificialFieldInsideNested() throws Exception { + runTest("compiler/testData/codegen/box/properties/classPrivateArtificialFieldInsideNested.kt"); + } + + @Test + @TestMetadata("companionFieldInsideLambda.kt") + public void testCompanionFieldInsideLambda() throws Exception { + runTest("compiler/testData/codegen/box/properties/companionFieldInsideLambda.kt"); + } + + @Test + @TestMetadata("companionPrivateField.kt") + public void testCompanionPrivateField() throws Exception { + runTest("compiler/testData/codegen/box/properties/companionPrivateField.kt"); + } + + @Test + @TestMetadata("companionPrivateFieldInsideLambda.kt") + public void testCompanionPrivateFieldInsideLambda() throws Exception { + runTest("compiler/testData/codegen/box/properties/companionPrivateFieldInsideLambda.kt"); + } + + @Test + @TestMetadata("complexPropertyInitializer.kt") + public void testComplexPropertyInitializer() throws Exception { + runTest("compiler/testData/codegen/box/properties/complexPropertyInitializer.kt"); + } + + @Test + @TestMetadata("field.kt") + public void testField() throws Exception { + runTest("compiler/testData/codegen/box/properties/field.kt"); + } + + @Test + @TestMetadata("fieldInClass.kt") + public void testFieldInClass() throws Exception { + runTest("compiler/testData/codegen/box/properties/fieldInClass.kt"); + } + + @Test + @TestMetadata("fieldInsideField.kt") + public void testFieldInsideField() throws Exception { + runTest("compiler/testData/codegen/box/properties/fieldInsideField.kt"); + } + + @Test + @TestMetadata("fieldInsideLambda.kt") + public void testFieldInsideLambda() throws Exception { + runTest("compiler/testData/codegen/box/properties/fieldInsideLambda.kt"); + } + + @Test + @TestMetadata("fieldInsideNested.kt") + public void testFieldInsideNested() throws Exception { + runTest("compiler/testData/codegen/box/properties/fieldInsideNested.kt"); + } + + @Test + @TestMetadata("fieldSimple.kt") + public void testFieldSimple() throws Exception { + runTest("compiler/testData/codegen/box/properties/fieldSimple.kt"); + } + + @Test + @TestMetadata("generalAccess.kt") + public void testGeneralAccess() throws Exception { + runTest("compiler/testData/codegen/box/properties/generalAccess.kt"); + } + + @Test + @TestMetadata("genericPropertyMultiModule.kt") + public void testGenericPropertyMultiModule() throws Exception { + runTest("compiler/testData/codegen/box/properties/genericPropertyMultiModule.kt"); + } + + @Test + @TestMetadata("genericWithSameName.kt") + public void testGenericWithSameName() throws Exception { + runTest("compiler/testData/codegen/box/properties/genericWithSameName.kt"); + } + + @Test + @TestMetadata("initOrderMultiModule.kt") + public void testInitOrderMultiModule() throws Exception { + runTest("compiler/testData/codegen/box/properties/initOrderMultiModule.kt"); + } + + @Test + @TestMetadata("initializerOfConstValWithConst.kt") + public void testInitializerOfConstValWithConst() throws Exception { + runTest("compiler/testData/codegen/box/properties/initializerOfConstValWithConst.kt"); + } + + @Test + @TestMetadata("initializerOfConstValWithConstExpr.kt") + public void testInitializerOfConstValWithConstExpr() throws Exception { + runTest("compiler/testData/codegen/box/properties/initializerOfConstValWithConstExpr.kt"); + } + + @Test + @TestMetadata("initializerOfValWithConstExpr.kt") + public void testInitializerOfValWithConstExpr() throws Exception { + runTest("compiler/testData/codegen/box/properties/initializerOfValWithConstExpr.kt"); + } + + @Test + @TestMetadata("initializerOfValWithNonConstExpr.kt") + public void testInitializerOfValWithNonConstExpr() throws Exception { + runTest("compiler/testData/codegen/box/properties/initializerOfValWithNonConstExpr.kt"); + } + + @Test + @TestMetadata("kt10715.kt") + public void testKt10715() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt10715.kt"); + } + + @Test + @TestMetadata("kt10729.kt") + public void testKt10729() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt10729.kt"); + } + + @Test + @TestMetadata("kt1159.kt") + public void testKt1159() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt1159.kt"); + } + + @Test + @TestMetadata("kt1165.kt") + public void testKt1165() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt1165.kt"); + } + + @Test + @TestMetadata("kt1168.kt") + public void testKt1168() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt1168.kt"); + } + + @Test + @TestMetadata("kt1170.kt") + public void testKt1170() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt1170.kt"); + } + + @Test + @TestMetadata("kt1398.kt") + public void testKt1398() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt1398.kt"); + } + + @Test + @TestMetadata("kt1417.kt") + public void testKt1417() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt1417.kt"); + } + + @Test + @TestMetadata("kt1714.kt") + public void testKt1714() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt1714.kt"); + } + + @Test + @TestMetadata("kt1714_minimal.kt") + public void testKt1714_minimal() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt1714_minimal.kt"); + } + + @Test + @TestMetadata("kt1892.kt") + public void testKt1892() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt1892.kt"); + } + + @Test + @TestMetadata("kt2331.kt") + public void testKt2331() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt2331.kt"); + } + + @Test + @TestMetadata("kt257.kt") + public void testKt257() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt257.kt"); + } + + @Test + @TestMetadata("kt2655.kt") + public void testKt2655() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt2655.kt"); + } + + @Test + @TestMetadata("kt2786.kt") + public void testKt2786() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt2786.kt"); + } + + @Test + @TestMetadata("kt2892.kt") + public void testKt2892() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt2892.kt"); + } + + @Test + @TestMetadata("kt3118.kt") + public void testKt3118() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt3118.kt"); + } + + @Test + @TestMetadata("kt3524.kt") + public void testKt3524() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt3524.kt"); + } + + @Test + @TestMetadata("kt3551.kt") + public void testKt3551() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt3551.kt"); + } + + @Test + @TestMetadata("kt3556.kt") + public void testKt3556() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt3556.kt"); + } + + @Test + @TestMetadata("kt3930.kt") + public void testKt3930() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt3930.kt"); + } + + @Test + @TestMetadata("kt4140.kt") + public void testKt4140() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt4140.kt"); + } + + @Test + @TestMetadata("kt4252.kt") + public void testKt4252() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt4252.kt"); + } + + @Test + @TestMetadata("kt4252_2.kt") + public void testKt4252_2() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt4252_2.kt"); + } + + @Test + @TestMetadata("kt4340.kt") + public void testKt4340() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt4340.kt"); + } + + @Test + @TestMetadata("kt4373.kt") + public void testKt4373() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt4373.kt"); + } + + @Test + @TestMetadata("kt4383.kt") + public void testKt4383() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt4383.kt"); + } + + @Test + @TestMetadata("kt49203_lateinit.kt") + public void testKt49203_lateinit() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt49203_lateinit.kt"); + } + + @Test + @TestMetadata("kt49203_var.kt") + public void testKt49203_var() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt49203_var.kt"); + } + + @Test + @TestMetadata("kt613.kt") + public void testKt613() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt613.kt"); + } + + @Test + @TestMetadata("kt8928.kt") + public void testKt8928() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt8928.kt"); + } + + @Test + @TestMetadata("kt9603.kt") + public void testKt9603() throws Exception { + runTest("compiler/testData/codegen/box/properties/kt9603.kt"); + } + + @Test + @TestMetadata("lazyInitialization.kt") + public void testLazyInitialization() throws Exception { + runTest("compiler/testData/codegen/box/properties/lazyInitialization.kt"); + } + + @Test + @TestMetadata("lazyInitializationCyclicImports.kt") + public void testLazyInitializationCyclicImports() throws Exception { + runTest("compiler/testData/codegen/box/properties/lazyInitializationCyclicImports.kt"); + } + + @Test + @TestMetadata("lazyInitializationMultiModule.kt") + public void testLazyInitializationMultiModule() throws Exception { + runTest("compiler/testData/codegen/box/properties/lazyInitializationMultiModule.kt"); + } + + @Test + @TestMetadata("lazyInitializationOrder.kt") + public void testLazyInitializationOrder() throws Exception { + runTest("compiler/testData/codegen/box/properties/lazyInitializationOrder.kt"); + } + + @Test + @TestMetadata("lazyInitializationSplitPerModule.kt") + public void testLazyInitializationSplitPerModule() throws Exception { + runTest("compiler/testData/codegen/box/properties/lazyInitializationSplitPerModule.kt"); + } + + @Test + @TestMetadata("primitiveOverrideDefaultAccessor.kt") + public void testPrimitiveOverrideDefaultAccessor() throws Exception { + runTest("compiler/testData/codegen/box/properties/primitiveOverrideDefaultAccessor.kt"); + } + + @Test + @TestMetadata("primitiveOverrideDelegateAccessor.kt") + public void testPrimitiveOverrideDelegateAccessor() throws Exception { + runTest("compiler/testData/codegen/box/properties/primitiveOverrideDelegateAccessor.kt"); + } + + @Test + @TestMetadata("privateAccessorOfOverriddenProperty.kt") + public void testPrivateAccessorOfOverriddenProperty() throws Exception { + runTest("compiler/testData/codegen/box/properties/privateAccessorOfOverriddenProperty.kt"); + } + + @Test + @TestMetadata("privatePropertyInConstructor.kt") + public void testPrivatePropertyInConstructor() throws Exception { + runTest("compiler/testData/codegen/box/properties/privatePropertyInConstructor.kt"); + } + + @Test + @TestMetadata("privatePropertyWithoutBackingField.kt") + public void testPrivatePropertyWithoutBackingField() throws Exception { + runTest("compiler/testData/codegen/box/properties/privatePropertyWithoutBackingField.kt"); + } + + @Test + @TestMetadata("twoAnnotatedExtensionPropertiesWithoutBackingFields.kt") + public void testTwoAnnotatedExtensionPropertiesWithoutBackingFields() throws Exception { + runTest("compiler/testData/codegen/box/properties/twoAnnotatedExtensionPropertiesWithoutBackingFields.kt"); + } + + @Test + @TestMetadata("typeInferredFromGetter.kt") + public void testTypeInferredFromGetter() throws Exception { + runTest("compiler/testData/codegen/box/properties/typeInferredFromGetter.kt"); + } + + @Test + @TestMetadata("unreachableUninitializedProperty.kt") + public void testUnreachableUninitializedProperty() throws Exception { + runTest("compiler/testData/codegen/box/properties/unreachableUninitializedProperty.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/properties/backingField") + @TestDataPath("$PROJECT_ROOT") + public class BackingField { + @Test + public void testAllFilesPresentInBackingField() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/backingField"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/properties/const") + @TestDataPath("$PROJECT_ROOT") + public class Const { + @Test + public void testAllFilesPresentInConst() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/const"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("anotherFile.kt") + public void testAnotherFile() throws Exception { + runTest("compiler/testData/codegen/box/properties/const/anotherFile.kt"); + } + + @Test + @TestMetadata("constPropertyAccessor.kt") + public void testConstPropertyAccessor() throws Exception { + runTest("compiler/testData/codegen/box/properties/const/constPropertyAccessor.kt"); + } + + @Test + @TestMetadata("intermoduleInlineConst.kt") + public void testIntermoduleInlineConst() throws Exception { + runTest("compiler/testData/codegen/box/properties/const/intermoduleInlineConst.kt"); + } + + @Test + @TestMetadata("kt52970.kt") + public void testKt52970() throws Exception { + runTest("compiler/testData/codegen/box/properties/const/kt52970.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/properties/lateinit") + @TestDataPath("$PROJECT_ROOT") + public class Lateinit { + @Test + @TestMetadata("accessor.kt") + public void testAccessor() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/accessor.kt"); + } + + @Test + @TestMetadata("accessorException.kt") + public void testAccessorException() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/accessorException.kt"); + } + + @Test + @TestMetadata("accessorExceptionPublic.kt") + public void testAccessorExceptionPublic() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/accessorExceptionPublic.kt"); + } + + @Test + public void testAllFilesPresentInLateinit() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("exceptionField.kt") + public void testExceptionField() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/exceptionField.kt"); + } + + @Test + @TestMetadata("exceptionGetter.kt") + public void testExceptionGetter() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/exceptionGetter.kt"); + } + + @Test + @TestMetadata("kt30548.kt") + public void testKt30548() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/kt30548.kt"); + } + + @Test + @TestMetadata("localClass.kt") + public void testLocalClass() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/localClass.kt"); + } + + @Test + @TestMetadata("nameClash.kt") + public void testNameClash() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/nameClash.kt"); + } + + @Test + @TestMetadata("override.kt") + public void testOverride() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/override.kt"); + } + + @Test + @TestMetadata("overrideException.kt") + public void testOverrideException() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/overrideException.kt"); + } + + @Test + @TestMetadata("privateSetter.kt") + public void testPrivateSetter() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/privateSetter.kt"); + } + + @Test + @TestMetadata("privateSetterFromLambda.kt") + public void testPrivateSetterFromLambda() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/privateSetterFromLambda.kt"); + } + + @Test + @TestMetadata("privateSetterViaSubclass.kt") + public void testPrivateSetterViaSubclass() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/privateSetterViaSubclass.kt"); + } + + @Test + @TestMetadata("privateVarInCompanion.kt") + public void testPrivateVarInCompanion() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/privateVarInCompanion.kt"); + } + + @Test + @TestMetadata("simpleVar.kt") + public void testSimpleVar() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/simpleVar.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize") + @TestDataPath("$PROJECT_ROOT") + public class IsInitializedAndDeinitialize { + @Test + public void testAllFilesPresentInIsInitializedAndDeinitialize() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("companionObjectField.kt") + public void testCompanionObjectField() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize/companionObjectField.kt"); + } + + @Test + @TestMetadata("emptyLhs.kt") + public void testEmptyLhs() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize/emptyLhs.kt"); + } + + @Test + @TestMetadata("innerSubclass.kt") + public void testInnerSubclass() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize/innerSubclass.kt"); + } + + @Test + @TestMetadata("isInitializedMultiFile.kt") + public void testIsInitializedMultiFile() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize/isInitializedMultiFile.kt"); + } + + @Test + @TestMetadata("nonInlineLambda.kt") + public void testNonInlineLambda() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize/nonInlineLambda.kt"); + } + + @Test + @TestMetadata("propertyImportedFromObject.kt") + public void testPropertyImportedFromObject() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize/propertyImportedFromObject.kt"); + } + + @Test + @TestMetadata("sideEffects.kt") + public void testSideEffects() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize/sideEffects.kt"); + } + + @Test + @TestMetadata("topLevelProperty.kt") + public void testTopLevelProperty() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/isInitializedAndDeinitialize/topLevelProperty.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/properties/lateinit/local") + @TestDataPath("$PROJECT_ROOT") + public class Local { + @Test + public void testAllFilesPresentInLocal() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/local"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("capturedLocalLateinit.kt") + public void testCapturedLocalLateinit() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/local/capturedLocalLateinit.kt"); + } + + @Test + @TestMetadata("kt23260.kt") + public void testKt23260() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/local/kt23260.kt"); + } + + @Test + @TestMetadata("localLateinit.kt") + public void testLocalLateinit() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/local/localLateinit.kt"); + } + + @Test + @TestMetadata("uninitializedCapturedMemberAccess.kt") + public void testUninitializedCapturedMemberAccess() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/local/uninitializedCapturedMemberAccess.kt"); + } + + @Test + @TestMetadata("uninitializedCapturedRead.kt") + public void testUninitializedCapturedRead() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/local/uninitializedCapturedRead.kt"); + } + + @Test + @TestMetadata("uninitializedMemberAccess.kt") + public void testUninitializedMemberAccess() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/local/uninitializedMemberAccess.kt"); + } + + @Test + @TestMetadata("uninitializedRead.kt") + public void testUninitializedRead() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/local/uninitializedRead.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/properties/lateinit/topLevel") + @TestDataPath("$PROJECT_ROOT") + public class TopLevel { + @Test + @TestMetadata("accessorException.kt") + public void testAccessorException() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/topLevel/accessorException.kt"); + } + + @Test + @TestMetadata("accessorForTopLevelLateinit.kt") + public void testAccessorForTopLevelLateinit() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/topLevel/accessorForTopLevelLateinit.kt"); + } + + @Test + public void testAllFilesPresentInTopLevel() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/properties/lateinit/topLevel"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("topLevelLateinit.kt") + public void testTopLevelLateinit() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/topLevel/topLevelLateinit.kt"); + } + + @Test + @TestMetadata("uninitializedMemberAccess.kt") + public void testUninitializedMemberAccess() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/topLevel/uninitializedMemberAccess.kt"); + } + + @Test + @TestMetadata("uninitializedRead.kt") + public void testUninitializedRead() throws Exception { + runTest("compiler/testData/codegen/box/properties/lateinit/topLevel/uninitializedRead.kt"); + } + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/publishedApi") + @TestDataPath("$PROJECT_ROOT") + public class PublishedApi { + @Test + public void testAllFilesPresentInPublishedApi() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/publishedApi"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("inlineFromFriendModule.kt") + public void testInlineFromFriendModule() throws Exception { + runTest("compiler/testData/codegen/box/publishedApi/inlineFromFriendModule.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/publishedApi/simple.kt"); + } + + @Test + @TestMetadata("topLevel.kt") + public void testTopLevel() throws Exception { + runTest("compiler/testData/codegen/box/publishedApi/topLevel.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges") + @TestDataPath("$PROJECT_ROOT") + public class Ranges { + @Test + public void testAllFilesPresentInRanges() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("capturedLoopVar.kt") + public void testCapturedLoopVar() throws Exception { + runTest("compiler/testData/codegen/box/ranges/capturedLoopVar.kt"); + } + + @Test + @TestMetadata("forByteProgressionWithIntIncrement.kt") + public void testForByteProgressionWithIntIncrement() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forByteProgressionWithIntIncrement.kt"); + } + + @Test + @TestMetadata("forInCharSequenceLengthDecreasedInLoopBody.kt") + public void testForInCharSequenceLengthDecreasedInLoopBody() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInCharSequenceLengthDecreasedInLoopBody.kt"); + } + + @Test + @TestMetadata("forInCharSequenceLengthIncreasedInLoopBody.kt") + public void testForInCharSequenceLengthIncreasedInLoopBody() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInCharSequenceLengthIncreasedInLoopBody.kt"); + } + + @Test + @TestMetadata("forInCharSequenceWithCustomIterator.kt") + public void testForInCharSequenceWithCustomIterator() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInCharSequenceWithCustomIterator.kt"); + } + + @Test + @TestMetadata("forInCharSequenceWithMultipleGetFunctions.kt") + public void testForInCharSequenceWithMultipleGetFunctions() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInCharSequenceWithMultipleGetFunctions.kt"); + } + + @Test + @TestMetadata("forInCustomCharSequence.kt") + public void testForInCustomCharSequence() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInCustomCharSequence.kt"); + } + + @Test + @TestMetadata("forInCustomIterable.kt") + public void testForInCustomIterable() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInCustomIterable.kt"); + } + + @Test + @TestMetadata("forInDoubleRangeWithCustomIterator.kt") + public void testForInDoubleRangeWithCustomIterator() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInDoubleRangeWithCustomIterator.kt"); + } + + @Test + @TestMetadata("forInFloatRangeWithCustomIterator.kt") + public void testForInFloatRangeWithCustomIterator() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInFloatRangeWithCustomIterator.kt"); + } + + @Test + @TestMetadata("forInIntRangeToConstWithBreak.kt") + public void testForInIntRangeToConstWithBreak() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIntRangeToConstWithBreak.kt"); + } + + @Test + @TestMetadata("forInIntRangeToConstWithContinue.kt") + public void testForInIntRangeToConstWithContinue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIntRangeToConstWithContinue.kt"); + } + + @Test + @TestMetadata("forInRangeLiteralWithMixedTypeBounds.kt") + public void testForInRangeLiteralWithMixedTypeBounds() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInRangeLiteralWithMixedTypeBounds.kt"); + } + + @Test + @TestMetadata("forInRangeWithImplicitReceiver.kt") + public void testForInRangeWithImplicitReceiver() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInRangeWithImplicitReceiver.kt"); + } + + @Test + @TestMetadata("forInStringVarUpdatedInLoopBody.kt") + public void testForInStringVarUpdatedInLoopBody() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInStringVarUpdatedInLoopBody.kt"); + } + + @Test + @TestMetadata("forIntRange.kt") + public void testForIntRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forIntRange.kt"); + } + + @Test + @TestMetadata("forNullableIntInRangeWithImplicitReceiver.kt") + public void testForNullableIntInRangeWithImplicitReceiver() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forNullableIntInRangeWithImplicitReceiver.kt"); + } + + @Test + @TestMetadata("kt37370.kt") + public void testKt37370() throws Exception { + runTest("compiler/testData/codegen/box/ranges/kt37370.kt"); + } + + @Test + @TestMetadata("kt37370a.kt") + public void testKt37370a() throws Exception { + runTest("compiler/testData/codegen/box/ranges/kt37370a.kt"); + } + + @Test + @TestMetadata("kt47492.kt") + public void testKt47492() throws Exception { + runTest("compiler/testData/codegen/box/ranges/kt47492.kt"); + } + + @Test + @TestMetadata("kt47492a.kt") + public void testKt47492a() throws Exception { + runTest("compiler/testData/codegen/box/ranges/kt47492a.kt"); + } + + @Test + @TestMetadata("kt47492b.kt") + public void testKt47492b() throws Exception { + runTest("compiler/testData/codegen/box/ranges/kt47492b.kt"); + } + + @Test + @TestMetadata("multiAssignmentIterationOverIntRange.kt") + public void testMultiAssignmentIterationOverIntRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/multiAssignmentIterationOverIntRange.kt"); + } + + @Test + @TestMetadata("safeCallRangeTo.kt") + public void testSafeCallRangeTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/safeCallRangeTo.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/contains") + @TestDataPath("$PROJECT_ROOT") + public class Contains { + @Test + public void testAllFilesPresentInContains() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("charInCharRangeWithPossibleOverflow.kt") + public void testCharInCharRangeWithPossibleOverflow() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/charInCharRangeWithPossibleOverflow.kt"); + } + + @Test + @TestMetadata("comparisonWithRangeBoundEliminated.kt") + public void testComparisonWithRangeBoundEliminated() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/comparisonWithRangeBoundEliminated.kt"); + } + + @Test + @TestMetadata("evaluationOrderForCollection.kt") + public void testEvaluationOrderForCollection() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/evaluationOrderForCollection.kt"); + } + + @Test + @TestMetadata("evaluationOrderForComparableRange.kt") + public void testEvaluationOrderForComparableRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/evaluationOrderForComparableRange.kt"); + } + + @Test + @TestMetadata("evaluationOrderForDownTo.kt") + public void testEvaluationOrderForDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/evaluationOrderForDownTo.kt"); + } + + @Test + @TestMetadata("evaluationOrderForDownToReversed.kt") + public void testEvaluationOrderForDownToReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/evaluationOrderForDownToReversed.kt"); + } + + @Test + @TestMetadata("evaluationOrderForNullableArgument.kt") + public void testEvaluationOrderForNullableArgument() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/evaluationOrderForNullableArgument.kt"); + } + + @Test + @TestMetadata("evaluationOrderForRangeLiteral.kt") + public void testEvaluationOrderForRangeLiteral() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/evaluationOrderForRangeLiteral.kt"); + } + + @Test + @TestMetadata("evaluationOrderForRangeLiteralReversed.kt") + public void testEvaluationOrderForRangeLiteralReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/evaluationOrderForRangeLiteralReversed.kt"); + } + + @Test + @TestMetadata("evaluationOrderForUntil.kt") + public void testEvaluationOrderForUntil() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/evaluationOrderForUntil.kt"); + } + + @Test + @TestMetadata("evaluationOrderForUntilReversed.kt") + public void testEvaluationOrderForUntilReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/evaluationOrderForUntilReversed.kt"); + } + + @Test + @TestMetadata("genericCharInRangeLiteral.kt") + public void testGenericCharInRangeLiteral() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/genericCharInRangeLiteral.kt"); + } + + @Test + @TestMetadata("inArray.kt") + public void testInArray() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/inArray.kt"); + } + + @Test + @TestMetadata("inCharSequence.kt") + public void testInCharSequence() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/inCharSequence.kt"); + } + + @Test + @TestMetadata("inComparableRange.kt") + public void testInComparableRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/inComparableRange.kt"); + } + + @Test + @TestMetadata("inCustomObjectRange.kt") + public void testInCustomObjectRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/inCustomObjectRange.kt"); + } + + @Test + @TestMetadata("inDoubleRangeLiteralVsComparableRangeLiteral.kt") + public void testInDoubleRangeLiteralVsComparableRangeLiteral() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/inDoubleRangeLiteralVsComparableRangeLiteral.kt"); + } + + @Test + @TestMetadata("inExtensionRange.kt") + public void testInExtensionRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/inExtensionRange.kt"); + } + + @Test + @TestMetadata("inFloatingPointRangeWithNaNBound.kt") + public void testInFloatingPointRangeWithNaNBound() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/inFloatingPointRangeWithNaNBound.kt"); + } + + @Test + @TestMetadata("inIntRange.kt") + public void testInIntRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/inIntRange.kt"); + } + + @Test + @TestMetadata("inIterable.kt") + public void testInIterable() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/inIterable.kt"); + } + + @Test + @TestMetadata("inNonMatchingRange.kt") + public void testInNonMatchingRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/inNonMatchingRange.kt"); + } + + @Test + @TestMetadata("inOptimizableDoubleRange.kt") + public void testInOptimizableDoubleRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/inOptimizableDoubleRange.kt"); + } + + @Test + @TestMetadata("inOptimizableFloatRange.kt") + public void testInOptimizableFloatRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/inOptimizableFloatRange.kt"); + } + + @Test + @TestMetadata("inOptimizableIntRange.kt") + public void testInOptimizableIntRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/inOptimizableIntRange.kt"); + } + + @Test + @TestMetadata("inOptimizableLongRange.kt") + public void testInOptimizableLongRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/inOptimizableLongRange.kt"); + } + + @Test + @TestMetadata("inPrimitiveProgression.kt") + public void testInPrimitiveProgression() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/inPrimitiveProgression.kt"); + } + + @Test + @TestMetadata("inPrimitiveRange.kt") + public void testInPrimitiveRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/inPrimitiveRange.kt"); + } + + @Test + @TestMetadata("inRangeLiteralComposition.kt") + public void testInRangeLiteralComposition() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/inRangeLiteralComposition.kt"); + } + + @Test + @TestMetadata("inRangeWithCustomContains.kt") + public void testInRangeWithCustomContains() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/inRangeWithCustomContains.kt"); + } + + @Test + @TestMetadata("inRangeWithImplicitReceiver.kt") + public void testInRangeWithImplicitReceiver() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/inRangeWithImplicitReceiver.kt"); + } + + @Test + @TestMetadata("inRangeWithNonmatchingArguments.kt") + public void testInRangeWithNonmatchingArguments() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/inRangeWithNonmatchingArguments.kt"); + } + + @Test + @TestMetadata("inRangeWithSmartCast.kt") + public void testInRangeWithSmartCast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/inRangeWithSmartCast.kt"); + } + + @Test + @TestMetadata("inUntil.kt") + public void testInUntil() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/inUntil.kt"); + } + + @Test + @TestMetadata("inUntilMaxValue.kt") + public void testInUntilMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/inUntilMaxValue.kt"); + } + + @Test + @TestMetadata("inUntilMinValue.kt") + public void testInUntilMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/inUntilMinValue.kt"); + } + + @Test + @TestMetadata("inUntilMinValueNonConst.kt") + public void testInUntilMinValueNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/inUntilMinValueNonConst.kt"); + } + + @Test + @TestMetadata("intInByteRangeWithPossibleOverflow.kt") + public void testIntInByteRangeWithPossibleOverflow() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/intInByteRangeWithPossibleOverflow.kt"); + } + + @Test + @TestMetadata("intInIntRangeWithPossibleOverflow.kt") + public void testIntInIntRangeWithPossibleOverflow() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/intInIntRangeWithPossibleOverflow.kt"); + } + + @Test + @TestMetadata("intInShortRangeWithPossibleOverflow.kt") + public void testIntInShortRangeWithPossibleOverflow() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/intInShortRangeWithPossibleOverflow.kt"); + } + + @Test + @TestMetadata("kt20106.kt") + public void testKt20106() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/kt20106.kt"); + } + + @Test + @TestMetadata("longInLongRangeWithPossibleOverflow.kt") + public void testLongInLongRangeWithPossibleOverflow() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/longInLongRangeWithPossibleOverflow.kt"); + } + + @Test + @TestMetadata("nullableInPrimitiveRange.kt") + public void testNullableInPrimitiveRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/nullableInPrimitiveRange.kt"); + } + + @Test + @TestMetadata("rangeContainsString.kt") + public void testRangeContainsString() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/rangeContainsString.kt"); + } + + @Test + @TestMetadata("smartCastOnBothEnds.kt") + public void testSmartCastOnBothEnds() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/smartCastOnBothEnds.kt"); + } + + @Test + @TestMetadata("uintInUByteRangeWithPossibleOverflow.kt") + public void testUintInUByteRangeWithPossibleOverflow() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/uintInUByteRangeWithPossibleOverflow.kt"); + } + + @Test + @TestMetadata("uintInUIntRangeWithPossibleOverflow.kt") + public void testUintInUIntRangeWithPossibleOverflow() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/uintInUIntRangeWithPossibleOverflow.kt"); + } + + @Test + @TestMetadata("uintInUShortRangeWithPossibleOverflow.kt") + public void testUintInUShortRangeWithPossibleOverflow() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/uintInUShortRangeWithPossibleOverflow.kt"); + } + + @Test + @TestMetadata("ulongInULongRangeWithPossibleOverflow.kt") + public void testUlongInULongRangeWithPossibleOverflow() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/ulongInULongRangeWithPossibleOverflow.kt"); + } + + @Test + @TestMetadata("userDefinedContainsExtension.kt") + public void testUserDefinedContainsExtension() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/userDefinedContainsExtension.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/contains/generated") + @TestDataPath("$PROJECT_ROOT") + public class Generated { + @Test + public void testAllFilesPresentInGenerated() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/contains/generated"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("arrayIndices.kt") + public void testArrayIndices() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/arrayIndices.kt"); + } + + @Test + @TestMetadata("charDownTo.kt") + public void testCharDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/charDownTo.kt"); + } + + @Test + @TestMetadata("charRangeTo.kt") + public void testCharRangeTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/charRangeTo.kt"); + } + + @Test + @TestMetadata("charRangeUntil.kt") + public void testCharRangeUntil() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/charRangeUntil.kt"); + } + + @Test + @TestMetadata("charSequenceIndices.kt") + public void testCharSequenceIndices() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/charSequenceIndices.kt"); + } + + @Test + @TestMetadata("charUntil.kt") + public void testCharUntil() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/charUntil.kt"); + } + + @Test + @TestMetadata("collectionIndices.kt") + public void testCollectionIndices() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/collectionIndices.kt"); + } + + @Test + @TestMetadata("doubleRangeTo.kt") + public void testDoubleRangeTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/doubleRangeTo.kt"); + } + + @Test + @TestMetadata("doubleRangeUntil.kt") + public void testDoubleRangeUntil() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/doubleRangeUntil.kt"); + } + + @Test + @TestMetadata("floatRangeTo.kt") + public void testFloatRangeTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/floatRangeTo.kt"); + } + + @Test + @TestMetadata("floatRangeUntil.kt") + public void testFloatRangeUntil() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/floatRangeUntil.kt"); + } + + @Test + @TestMetadata("intDownTo.kt") + public void testIntDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/intDownTo.kt"); + } + + @Test + @TestMetadata("intRangeTo.kt") + public void testIntRangeTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/intRangeTo.kt"); + } + + @Test + @TestMetadata("intRangeUntil.kt") + public void testIntRangeUntil() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/intRangeUntil.kt"); + } + + @Test + @TestMetadata("intUntil.kt") + public void testIntUntil() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/intUntil.kt"); + } + + @Test + @TestMetadata("longDownTo.kt") + public void testLongDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/longDownTo.kt"); + } + + @Test + @TestMetadata("longRangeTo.kt") + public void testLongRangeTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/longRangeTo.kt"); + } + + @Test + @TestMetadata("longRangeUntil.kt") + public void testLongRangeUntil() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/longRangeUntil.kt"); + } + + @Test + @TestMetadata("longUntil.kt") + public void testLongUntil() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/longUntil.kt"); + } + + @Test + @TestMetadata("uintDownTo.kt") + public void testUintDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/uintDownTo.kt"); + } + + @Test + @TestMetadata("uintRangeTo.kt") + public void testUintRangeTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/uintRangeTo.kt"); + } + + @Test + @TestMetadata("uintRangeUntil.kt") + public void testUintRangeUntil() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/uintRangeUntil.kt"); + } + + @Test + @TestMetadata("uintUntil.kt") + public void testUintUntil() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/uintUntil.kt"); + } + + @Test + @TestMetadata("ulongDownTo.kt") + public void testUlongDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/ulongDownTo.kt"); + } + + @Test + @TestMetadata("ulongRangeTo.kt") + public void testUlongRangeTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/ulongRangeTo.kt"); + } + + @Test + @TestMetadata("ulongRangeUntil.kt") + public void testUlongRangeUntil() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/ulongRangeUntil.kt"); + } + + @Test + @TestMetadata("ulongUntil.kt") + public void testUlongUntil() throws Exception { + runTest("compiler/testData/codegen/box/ranges/contains/generated/ulongUntil.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/evaluationOrder") + @TestDataPath("$PROJECT_ROOT") + public class EvaluationOrder { + @Test + public void testAllFilesPresentInEvaluationOrder() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("forInDownTo.kt") + public void testForInDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/forInDownTo.kt"); + } + + @Test + @TestMetadata("forInDownToReversed.kt") + public void testForInDownToReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/forInDownToReversed.kt"); + } + + @Test + @TestMetadata("forInDownToReversedReversed.kt") + public void testForInDownToReversedReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/forInDownToReversedReversed.kt"); + } + + @Test + @TestMetadata("forInRangeLiteral.kt") + public void testForInRangeLiteral() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/forInRangeLiteral.kt"); + } + + @Test + @TestMetadata("forInRangeLiteralReversed.kt") + public void testForInRangeLiteralReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/forInRangeLiteralReversed.kt"); + } + + @Test + @TestMetadata("forInRangeLiteralReversedReversed.kt") + public void testForInRangeLiteralReversedReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/forInRangeLiteralReversedReversed.kt"); + } + + @Test + @TestMetadata("forInUntil.kt") + public void testForInUntil() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/forInUntil.kt"); + } + + @Test + @TestMetadata("forInUntilReversed.kt") + public void testForInUntilReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/forInUntilReversed.kt"); + } + + @Test + @TestMetadata("forInUntilReversedReversed.kt") + public void testForInUntilReversedReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/forInUntilReversedReversed.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/evaluationOrder/stepped") + @TestDataPath("$PROJECT_ROOT") + public class Stepped { + @Test + public void testAllFilesPresentInStepped() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo") + @TestDataPath("$PROJECT_ROOT") + public class ForInDownTo { + @Test + public void testAllFilesPresentInForInDownTo() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("forInDownToReversedStep.kt") + public void testForInDownToReversedStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo/forInDownToReversedStep.kt"); + } + + @Test + @TestMetadata("forInDownToReversedStepReversed.kt") + public void testForInDownToReversedStepReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo/forInDownToReversedStepReversed.kt"); + } + + @Test + @TestMetadata("forInDownToReversedStepReversedStep.kt") + public void testForInDownToReversedStepReversedStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo/forInDownToReversedStepReversedStep.kt"); + } + + @Test + @TestMetadata("forInDownToStep.kt") + public void testForInDownToStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo/forInDownToStep.kt"); + } + + @Test + @TestMetadata("forInDownToStepReversed.kt") + public void testForInDownToStepReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo/forInDownToStepReversed.kt"); + } + + @Test + @TestMetadata("forInDownToStepReversedStep.kt") + public void testForInDownToStepReversedStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo/forInDownToStepReversedStep.kt"); + } + + @Test + @TestMetadata("forInDownToStepReversedStepReversed.kt") + public void testForInDownToStepReversedStepReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo/forInDownToStepReversedStepReversed.kt"); + } + + @Test + @TestMetadata("forInDownToStepStep.kt") + public void testForInDownToStepStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInDownTo/forInDownToStepStep.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral") + @TestDataPath("$PROJECT_ROOT") + public class ForInRangeLiteral { + @Test + public void testAllFilesPresentInForInRangeLiteral() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("forInRangeLiteralReversedStep.kt") + public void testForInRangeLiteralReversedStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral/forInRangeLiteralReversedStep.kt"); + } + + @Test + @TestMetadata("forInRangeLiteralReversedStepReversed.kt") + public void testForInRangeLiteralReversedStepReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral/forInRangeLiteralReversedStepReversed.kt"); + } + + @Test + @TestMetadata("forInRangeLiteralReversedStepReversedStep.kt") + public void testForInRangeLiteralReversedStepReversedStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral/forInRangeLiteralReversedStepReversedStep.kt"); + } + + @Test + @TestMetadata("forInRangeLiteralStep.kt") + public void testForInRangeLiteralStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral/forInRangeLiteralStep.kt"); + } + + @Test + @TestMetadata("forInRangeLiteralStepReversed.kt") + public void testForInRangeLiteralStepReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral/forInRangeLiteralStepReversed.kt"); + } + + @Test + @TestMetadata("forInRangeLiteralStepReversedStep.kt") + public void testForInRangeLiteralStepReversedStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral/forInRangeLiteralStepReversedStep.kt"); + } + + @Test + @TestMetadata("forInRangeLiteralStepReversedStepReversed.kt") + public void testForInRangeLiteralStepReversedStepReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral/forInRangeLiteralStepReversedStepReversed.kt"); + } + + @Test + @TestMetadata("forInRangeLiteralStepStep.kt") + public void testForInRangeLiteralStepStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInRangeLiteral/forInRangeLiteralStepStep.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil") + @TestDataPath("$PROJECT_ROOT") + public class ForInUntil { + @Test + public void testAllFilesPresentInForInUntil() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("forInUntilReversedStep.kt") + public void testForInUntilReversedStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil/forInUntilReversedStep.kt"); + } + + @Test + @TestMetadata("forInUntilReversedStepReversed.kt") + public void testForInUntilReversedStepReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil/forInUntilReversedStepReversed.kt"); + } + + @Test + @TestMetadata("forInUntilReversedStepReversedStep.kt") + public void testForInUntilReversedStepReversedStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil/forInUntilReversedStepReversedStep.kt"); + } + + @Test + @TestMetadata("forInUntilStep.kt") + public void testForInUntilStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil/forInUntilStep.kt"); + } + + @Test + @TestMetadata("forInUntilStepReversed.kt") + public void testForInUntilStepReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil/forInUntilStepReversed.kt"); + } + + @Test + @TestMetadata("forInUntilStepReversedStep.kt") + public void testForInUntilStepReversedStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil/forInUntilStepReversedStep.kt"); + } + + @Test + @TestMetadata("forInUntilStepReversedStepReversed.kt") + public void testForInUntilStepReversedStepReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil/forInUntilStepReversedStepReversed.kt"); + } + + @Test + @TestMetadata("forInUntilStepStep.kt") + public void testForInUntilStepStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/evaluationOrder/stepped/forInUntil/forInUntilStepStep.kt"); + } + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/expression") + @TestDataPath("$PROJECT_ROOT") + public class Expression { + @Test + public void testAllFilesPresentInExpression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/expression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("emptyDownto.kt") + public void testEmptyDownto() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/emptyDownto.kt"); + } + + @Test + @TestMetadata("emptyRange.kt") + public void testEmptyRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/emptyRange.kt"); + } + + @Test + @TestMetadata("inexactDownToMinValue.kt") + public void testInexactDownToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/inexactDownToMinValue.kt"); + } + + @Test + @TestMetadata("inexactSteppedDownTo.kt") + public void testInexactSteppedDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/inexactSteppedDownTo.kt"); + } + + @Test + @TestMetadata("inexactSteppedRange.kt") + public void testInexactSteppedRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/inexactSteppedRange.kt"); + } + + @Test + @TestMetadata("inexactToMaxValue.kt") + public void testInexactToMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/inexactToMaxValue.kt"); + } + + @Test + @TestMetadata("maxValueMinusTwoToMaxValue.kt") + public void testMaxValueMinusTwoToMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/maxValueMinusTwoToMaxValue.kt"); + } + + @Test + @TestMetadata("maxValueToMaxValue.kt") + public void testMaxValueToMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/maxValueToMaxValue.kt"); + } + + @Test + @TestMetadata("maxValueToMinValue.kt") + public void testMaxValueToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/maxValueToMinValue.kt"); + } + + @Test + @TestMetadata("oneElementDownTo.kt") + public void testOneElementDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/oneElementDownTo.kt"); + } + + @Test + @TestMetadata("oneElementRange.kt") + public void testOneElementRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/oneElementRange.kt"); + } + + @Test + @TestMetadata("openRange.kt") + public void testOpenRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/openRange.kt"); + } + + @Test + @TestMetadata("openRangeUntil.kt") + public void testOpenRangeUntil() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/openRangeUntil.kt"); + } + + @Test + @TestMetadata("overflowZeroDownToMaxValue.kt") + public void testOverflowZeroDownToMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/overflowZeroDownToMaxValue.kt"); + } + + @Test + @TestMetadata("overflowZeroToMinValue.kt") + public void testOverflowZeroToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/overflowZeroToMinValue.kt"); + } + + @Test + @TestMetadata("progressionDownToMinValue.kt") + public void testProgressionDownToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/progressionDownToMinValue.kt"); + } + + @Test + @TestMetadata("progressionMaxValueMinusTwoToMaxValue.kt") + public void testProgressionMaxValueMinusTwoToMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/progressionMaxValueMinusTwoToMaxValue.kt"); + } + + @Test + @TestMetadata("progressionMaxValueToMaxValue.kt") + public void testProgressionMaxValueToMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/progressionMaxValueToMaxValue.kt"); + } + + @Test + @TestMetadata("progressionMaxValueToMinValue.kt") + public void testProgressionMaxValueToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/progressionMaxValueToMinValue.kt"); + } + + @Test + @TestMetadata("progressionMinValueToMinValue.kt") + public void testProgressionMinValueToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/progressionMinValueToMinValue.kt"); + } + + @Test + @TestMetadata("reversedBackSequence.kt") + public void testReversedBackSequence() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/reversedBackSequence.kt"); + } + + @Test + @TestMetadata("reversedEmptyBackSequence.kt") + public void testReversedEmptyBackSequence() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/reversedEmptyBackSequence.kt"); + } + + @Test + @TestMetadata("reversedEmptyRange.kt") + public void testReversedEmptyRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/reversedEmptyRange.kt"); + } + + @Test + @TestMetadata("reversedInexactSteppedDownTo.kt") + public void testReversedInexactSteppedDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/reversedInexactSteppedDownTo.kt"); + } + + @Test + @TestMetadata("reversedRange.kt") + public void testReversedRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/reversedRange.kt"); + } + + @Test + @TestMetadata("reversedSimpleSteppedRange.kt") + public void testReversedSimpleSteppedRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/reversedSimpleSteppedRange.kt"); + } + + @Test + @TestMetadata("simpleDownTo.kt") + public void testSimpleDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/simpleDownTo.kt"); + } + + @Test + @TestMetadata("simpleRange.kt") + public void testSimpleRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/simpleRange.kt"); + } + + @Test + @TestMetadata("simpleRangeWithNonConstantEnds.kt") + public void testSimpleRangeWithNonConstantEnds() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/simpleRangeWithNonConstantEnds.kt"); + } + + @Test + @TestMetadata("simpleSteppedDownTo.kt") + public void testSimpleSteppedDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/simpleSteppedDownTo.kt"); + } + + @Test + @TestMetadata("simpleSteppedRange.kt") + public void testSimpleSteppedRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/expression/simpleSteppedRange.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/forInDownTo") + @TestDataPath("$PROJECT_ROOT") + public class ForInDownTo { + @Test + public void testAllFilesPresentInForInDownTo() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInDownTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("forInDownToWithPossibleUnderflow.kt") + public void testForInDownToWithPossibleUnderflow() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInDownTo/forInDownToWithPossibleUnderflow.kt"); + } + + @Test + @TestMetadata("forInSumDownToSum.kt") + public void testForInSumDownToSum() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInDownTo/forInSumDownToSum.kt"); + } + + @Test + @TestMetadata("forIntInDownTo.kt") + public void testForIntInDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInDownTo/forIntInDownTo.kt"); + } + + @Test + @TestMetadata("forIntInDownToWithNonConstBounds.kt") + public void testForIntInDownToWithNonConstBounds() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInDownTo/forIntInDownToWithNonConstBounds.kt"); + } + + @Test + @TestMetadata("forIntInNonOptimizedDownTo.kt") + public void testForIntInNonOptimizedDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInDownTo/forIntInNonOptimizedDownTo.kt"); + } + + @Test + @TestMetadata("forLongInDownTo.kt") + public void testForLongInDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInDownTo/forLongInDownTo.kt"); + } + + @Test + @TestMetadata("forNullableIntInDownTo.kt") + public void testForNullableIntInDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInDownTo/forNullableIntInDownTo.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/forInIndices") + @TestDataPath("$PROJECT_ROOT") + public class ForInIndices { + @Test + public void testAllFilesPresentInForInIndices() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInIndices"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("forInArrayListIndices.kt") + public void testForInArrayListIndices() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIndices/forInArrayListIndices.kt"); + } + + @Test + @TestMetadata("forInCharSequenceIndices.kt") + public void testForInCharSequenceIndices() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIndices/forInCharSequenceIndices.kt"); + } + + @Test + @TestMetadata("forInCharSequenceTypeParameterIndices.kt") + public void testForInCharSequenceTypeParameterIndices() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIndices/forInCharSequenceTypeParameterIndices.kt"); + } + + @Test + @TestMetadata("forInCollectionImplicitReceiverIndices.kt") + public void testForInCollectionImplicitReceiverIndices() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIndices/forInCollectionImplicitReceiverIndices.kt"); + } + + @Test + @TestMetadata("forInCollectionIndices.kt") + public void testForInCollectionIndices() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIndices/forInCollectionIndices.kt"); + } + + @Test + @TestMetadata("forInCollectionTypeParameterIndices.kt") + public void testForInCollectionTypeParameterIndices() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIndices/forInCollectionTypeParameterIndices.kt"); + } + + @Test + @TestMetadata("forInListIndices.kt") + public void testForInListIndices() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIndices/forInListIndices.kt"); + } + + @Test + @TestMetadata("forInListIndicesBreak.kt") + public void testForInListIndicesBreak() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIndices/forInListIndicesBreak.kt"); + } + + @Test + @TestMetadata("forInListIndicesContinue.kt") + public void testForInListIndicesContinue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIndices/forInListIndicesContinue.kt"); + } + + @Test + @TestMetadata("forInNonOptimizedIndices.kt") + public void testForInNonOptimizedIndices() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIndices/forInNonOptimizedIndices.kt"); + } + + @Test + @TestMetadata("forInObjectArrayIndices.kt") + public void testForInObjectArrayIndices() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIndices/forInObjectArrayIndices.kt"); + } + + @Test + @TestMetadata("forInPrimitiveArrayIndices.kt") + public void testForInPrimitiveArrayIndices() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIndices/forInPrimitiveArrayIndices.kt"); + } + + @Test + @TestMetadata("forNullableIntInArrayIndices.kt") + public void testForNullableIntInArrayIndices() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIndices/forNullableIntInArrayIndices.kt"); + } + + @Test + @TestMetadata("forNullableIntInCollectionIndices.kt") + public void testForNullableIntInCollectionIndices() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIndices/forNullableIntInCollectionIndices.kt"); + } + + @Test + @TestMetadata("indexOfLast.kt") + public void testIndexOfLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIndices/indexOfLast.kt"); + } + + @Test + @TestMetadata("kt12983_forInGenericArrayIndices.kt") + public void testKt12983_forInGenericArrayIndices() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIndices/kt12983_forInGenericArrayIndices.kt"); + } + + @Test + @TestMetadata("kt12983_forInGenericCollectionIndices.kt") + public void testKt12983_forInGenericCollectionIndices() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIndices/kt12983_forInGenericCollectionIndices.kt"); + } + + @Test + @TestMetadata("kt12983_forInSpecificArrayIndices.kt") + public void testKt12983_forInSpecificArrayIndices() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIndices/kt12983_forInSpecificArrayIndices.kt"); + } + + @Test + @TestMetadata("kt12983_forInSpecificCollectionIndices.kt") + public void testKt12983_forInSpecificCollectionIndices() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIndices/kt12983_forInSpecificCollectionIndices.kt"); + } + + @Test + @TestMetadata("kt13241_Array.kt") + public void testKt13241_Array() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIndices/kt13241_Array.kt"); + } + + @Test + @TestMetadata("kt13241_CharSequence.kt") + public void testKt13241_CharSequence() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIndices/kt13241_CharSequence.kt"); + } + + @Test + @TestMetadata("kt13241_Collection.kt") + public void testKt13241_Collection() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIndices/kt13241_Collection.kt"); + } + + @Test + @TestMetadata("kt43159_ArrayUpperBound.kt") + public void testKt43159_ArrayUpperBound() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIndices/kt43159_ArrayUpperBound.kt"); + } + + @Test + @TestMetadata("kt43159_GenericArray.kt") + public void testKt43159_GenericArray() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInIndices/kt43159_GenericArray.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/forInProgressionWithIndex") + @TestDataPath("$PROJECT_ROOT") + public class ForInProgressionWithIndex { + @Test + public void testAllFilesPresentInForInProgressionWithIndex() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInProgressionWithIndex"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("forInDownToWithIndex.kt") + public void testForInDownToWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInDownToWithIndex.kt"); + } + + @Test + @TestMetadata("forInIndicesWithIndex.kt") + public void testForInIndicesWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInIndicesWithIndex.kt"); + } + + @Test + @TestMetadata("forInRangeToWithIndex.kt") + public void testForInRangeToWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInRangeToWithIndex.kt"); + } + + @Test + @TestMetadata("forInReversedStepWithIndex.kt") + public void testForInReversedStepWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInReversedStepWithIndex.kt"); + } + + @Test + @TestMetadata("forInReversedWithIndex.kt") + public void testForInReversedWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInReversedWithIndex.kt"); + } + + @Test + @TestMetadata("forInStepReversedWithIndex.kt") + public void testForInStepReversedWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInStepReversedWithIndex.kt"); + } + + @Test + @TestMetadata("forInStepWithIndex.kt") + public void testForInStepWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInStepWithIndex.kt"); + } + + @Test + @TestMetadata("forInUntilWithIndex.kt") + public void testForInUntilWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInUntilWithIndex.kt"); + } + + @Test + @TestMetadata("forInWithIndexBreakAndContinue.kt") + public void testForInWithIndexBreakAndContinue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInWithIndexBreakAndContinue.kt"); + } + + @Test + @TestMetadata("forInWithIndexNoIndexOrElementVar.kt") + public void testForInWithIndexNoIndexOrElementVar() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInWithIndexNoIndexOrElementVar.kt"); + } + + @Test + @TestMetadata("forInWithIndexNotDestructured.kt") + public void testForInWithIndexNotDestructured() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInWithIndexNotDestructured.kt"); + } + + @Test + @TestMetadata("forInWithIndexReversed.kt") + public void testForInWithIndexReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInWithIndexReversed.kt"); + } + + @Test + @TestMetadata("forInWithIndexWithDestructuringInLoop.kt") + public void testForInWithIndexWithDestructuringInLoop() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInWithIndexWithDestructuringInLoop.kt"); + } + + @Test + @TestMetadata("forInWithIndexWithIndex.kt") + public void testForInWithIndexWithIndex() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/forInWithIndexWithIndex.kt"); + } + + @Test + @TestMetadata("kt42909.kt") + public void testKt42909() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInProgressionWithIndex/kt42909.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/forInReversed") + @TestDataPath("$PROJECT_ROOT") + public class ForInReversed { + @Test + public void testAllFilesPresentInForInReversed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInReversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("forInReversedArrayIndices.kt") + public void testForInReversedArrayIndices() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedArrayIndices.kt"); + } + + @Test + @TestMetadata("forInReversedCharSequenceIndices.kt") + public void testForInReversedCharSequenceIndices() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedCharSequenceIndices.kt"); + } + + @Test + @TestMetadata("forInReversedCollectionIndices.kt") + public void testForInReversedCollectionIndices() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedCollectionIndices.kt"); + } + + @Test + @TestMetadata("forInReversedDownTo.kt") + public void testForInReversedDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedDownTo.kt"); + } + + @Test + @TestMetadata("forInReversedEmptyRange.kt") + public void testForInReversedEmptyRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedEmptyRange.kt"); + } + + @Test + @TestMetadata("forInReversedEmptyRangeLiteral.kt") + public void testForInReversedEmptyRangeLiteral() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedEmptyRangeLiteral.kt"); + } + + @Test + @TestMetadata("forInReversedEmptyRangeLiteralWithNonConstBounds.kt") + public void testForInReversedEmptyRangeLiteralWithNonConstBounds() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedEmptyRangeLiteralWithNonConstBounds.kt"); + } + + @Test + @TestMetadata("forInReversedRange.kt") + public void testForInReversedRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedRange.kt"); + } + + @Test + @TestMetadata("forInReversedRangeLiteral.kt") + public void testForInReversedRangeLiteral() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedRangeLiteral.kt"); + } + + @Test + @TestMetadata("forInReversedRangeLiteralWithNonConstBounds.kt") + public void testForInReversedRangeLiteralWithNonConstBounds() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedRangeLiteralWithNonConstBounds.kt"); + } + + @Test + @TestMetadata("forInReversedReversedArrayIndices.kt") + public void testForInReversedReversedArrayIndices() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedReversedArrayIndices.kt"); + } + + @Test + @TestMetadata("forInReversedReversedDownTo.kt") + public void testForInReversedReversedDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedReversedDownTo.kt"); + } + + @Test + @TestMetadata("ForInReversedReversedRange.kt") + public void testForInReversedReversedRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInReversed/ForInReversedReversedRange.kt"); + } + + @Test + @TestMetadata("forInReversedReversedReversedRange.kt") + public void testForInReversedReversedReversedRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedReversedReversedRange.kt"); + } + + @Test + @TestMetadata("forInReversedReversedUntil.kt") + public void testForInReversedReversedUntil() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedReversedUntil.kt"); + } + + @Test + @TestMetadata("forInReversedReversedUntilWithNonConstBounds.kt") + public void testForInReversedReversedUntilWithNonConstBounds() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedReversedUntilWithNonConstBounds.kt"); + } + + @Test + @TestMetadata("forInReversedUntil.kt") + public void testForInReversedUntil() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedUntil.kt"); + } + + @Test + @TestMetadata("forInReversedUntilWithNonConstBounds.kt") + public void testForInReversedUntilWithNonConstBounds() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInReversed/forInReversedUntilWithNonConstBounds.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/forInUntil") + @TestDataPath("$PROJECT_ROOT") + public class ForInUntil { + @Test + public void testAllFilesPresentInForInUntil() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forInUntil"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("forInUntilChar.kt") + public void testForInUntilChar() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilChar.kt"); + } + + @Test + @TestMetadata("forInUntilCharMaxValue.kt") + public void testForInUntilCharMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilCharMaxValue.kt"); + } + + @Test + @TestMetadata("forInUntilCharMinValue.kt") + public void testForInUntilCharMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilCharMinValue.kt"); + } + + @Test + @TestMetadata("forInUntilCharMinValueNonConst.kt") + public void testForInUntilCharMinValueNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilCharMinValueNonConst.kt"); + } + + @Test + @TestMetadata("forInUntilInt.kt") + public void testForInUntilInt() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilInt.kt"); + } + + @Test + @TestMetadata("forInUntilIntMaxValue.kt") + public void testForInUntilIntMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilIntMaxValue.kt"); + } + + @Test + @TestMetadata("forInUntilIntMinValue.kt") + public void testForInUntilIntMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilIntMinValue.kt"); + } + + @Test + @TestMetadata("forInUntilIntMinValueNonConst.kt") + public void testForInUntilIntMinValueNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilIntMinValueNonConst.kt"); + } + + @Test + @TestMetadata("forInUntilLesserInt.kt") + public void testForInUntilLesserInt() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilLesserInt.kt"); + } + + @Test + @TestMetadata("forInUntilLong.kt") + public void testForInUntilLong() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilLong.kt"); + } + + @Test + @TestMetadata("forInUntilLongMaxValue.kt") + public void testForInUntilLongMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilLongMaxValue.kt"); + } + + @Test + @TestMetadata("forInUntilLongMinValue.kt") + public void testForInUntilLongMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilLongMinValue.kt"); + } + + @Test + @TestMetadata("forInUntilLongMinValueNonConst.kt") + public void testForInUntilLongMinValueNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInUntil/forInUntilLongMinValueNonConst.kt"); + } + + @Test + @TestMetadata("forIntInIntUntilSmartcastInt.kt") + public void testForIntInIntUntilSmartcastInt() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInUntil/forIntInIntUntilSmartcastInt.kt"); + } + + @Test + @TestMetadata("kt42533.kt") + public void testKt42533() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forInUntil/kt42533.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/forWithPossibleOverflow") + @TestDataPath("$PROJECT_ROOT") + public class ForWithPossibleOverflow { + @Test + public void testAllFilesPresentInForWithPossibleOverflow() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/forWithPossibleOverflow"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("forInDownToCharMinValue.kt") + public void testForInDownToCharMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInDownToCharMinValue.kt"); + } + + @Test + @TestMetadata("forInDownToCharMinValueReversed.kt") + public void testForInDownToCharMinValueReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInDownToCharMinValueReversed.kt"); + } + + @Test + @TestMetadata("forInDownToIntMinValue.kt") + public void testForInDownToIntMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInDownToIntMinValue.kt"); + } + + @Test + @TestMetadata("forInDownToIntMinValueReversed.kt") + public void testForInDownToIntMinValueReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInDownToIntMinValueReversed.kt"); + } + + @Test + @TestMetadata("forInDownToLongMinValue.kt") + public void testForInDownToLongMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInDownToLongMinValue.kt"); + } + + @Test + @TestMetadata("forInDownToLongMinValueReversed.kt") + public void testForInDownToLongMinValueReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInDownToLongMinValueReversed.kt"); + } + + @Test + @TestMetadata("forInRangeToCharMaxValue.kt") + public void testForInRangeToCharMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInRangeToCharMaxValue.kt"); + } + + @Test + @TestMetadata("forInRangeToCharMaxValueReversed.kt") + public void testForInRangeToCharMaxValueReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInRangeToCharMaxValueReversed.kt"); + } + + @Test + @TestMetadata("forInRangeToIntMaxValue.kt") + public void testForInRangeToIntMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInRangeToIntMaxValue.kt"); + } + + @Test + @TestMetadata("forInRangeToIntMaxValueReversed.kt") + public void testForInRangeToIntMaxValueReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInRangeToIntMaxValueReversed.kt"); + } + + @Test + @TestMetadata("forInRangeToLongMaxValue.kt") + public void testForInRangeToLongMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInRangeToLongMaxValue.kt"); + } + + @Test + @TestMetadata("forInRangeToLongMaxValueReversed.kt") + public void testForInRangeToLongMaxValueReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInRangeToLongMaxValueReversed.kt"); + } + + @Test + @TestMetadata("forInUntilIntMinValueReversed.kt") + public void testForInUntilIntMinValueReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/forWithPossibleOverflow/forInUntilIntMinValueReversed.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/javaInterop") + @TestDataPath("$PROJECT_ROOT") + public class JavaInterop { + @Test + public void testAllFilesPresentInJavaInterop() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/javaInterop/withIndex") + @TestDataPath("$PROJECT_ROOT") + public class WithIndex { + @Test + public void testAllFilesPresentInWithIndex() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/javaInterop/withIndex"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/literal") + @TestDataPath("$PROJECT_ROOT") + public class Literal { + @Test + public void testAllFilesPresentInLiteral() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/literal"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("emptyDownto.kt") + public void testEmptyDownto() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/emptyDownto.kt"); + } + + @Test + @TestMetadata("emptyRange.kt") + public void testEmptyRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/emptyRange.kt"); + } + + @Test + @TestMetadata("inexactDownToMinValue.kt") + public void testInexactDownToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/inexactDownToMinValue.kt"); + } + + @Test + @TestMetadata("inexactSteppedDownTo.kt") + public void testInexactSteppedDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/inexactSteppedDownTo.kt"); + } + + @Test + @TestMetadata("inexactSteppedRange.kt") + public void testInexactSteppedRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/inexactSteppedRange.kt"); + } + + @Test + @TestMetadata("inexactToMaxValue.kt") + public void testInexactToMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/inexactToMaxValue.kt"); + } + + @Test + @TestMetadata("maxValueMinusTwoToMaxValue.kt") + public void testMaxValueMinusTwoToMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/maxValueMinusTwoToMaxValue.kt"); + } + + @Test + @TestMetadata("maxValueToMaxValue.kt") + public void testMaxValueToMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/maxValueToMaxValue.kt"); + } + + @Test + @TestMetadata("maxValueToMinValue.kt") + public void testMaxValueToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/maxValueToMinValue.kt"); + } + + @Test + @TestMetadata("oneElementDownTo.kt") + public void testOneElementDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/oneElementDownTo.kt"); + } + + @Test + @TestMetadata("oneElementRange.kt") + public void testOneElementRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/oneElementRange.kt"); + } + + @Test + @TestMetadata("openRange.kt") + public void testOpenRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/openRange.kt"); + } + + @Test + @TestMetadata("openRangeUntil.kt") + public void testOpenRangeUntil() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/openRangeUntil.kt"); + } + + @Test + @TestMetadata("overflowZeroDownToMaxValue.kt") + public void testOverflowZeroDownToMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/overflowZeroDownToMaxValue.kt"); + } + + @Test + @TestMetadata("overflowZeroToMinValue.kt") + public void testOverflowZeroToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/overflowZeroToMinValue.kt"); + } + + @Test + @TestMetadata("progressionDownToMinValue.kt") + public void testProgressionDownToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/progressionDownToMinValue.kt"); + } + + @Test + @TestMetadata("progressionMaxValueMinusTwoToMaxValue.kt") + public void testProgressionMaxValueMinusTwoToMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/progressionMaxValueMinusTwoToMaxValue.kt"); + } + + @Test + @TestMetadata("progressionMaxValueToMaxValue.kt") + public void testProgressionMaxValueToMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/progressionMaxValueToMaxValue.kt"); + } + + @Test + @TestMetadata("progressionMaxValueToMinValue.kt") + public void testProgressionMaxValueToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/progressionMaxValueToMinValue.kt"); + } + + @Test + @TestMetadata("progressionMinValueToMinValue.kt") + public void testProgressionMinValueToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/progressionMinValueToMinValue.kt"); + } + + @Test + @TestMetadata("reversedBackSequence.kt") + public void testReversedBackSequence() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/reversedBackSequence.kt"); + } + + @Test + @TestMetadata("reversedEmptyBackSequence.kt") + public void testReversedEmptyBackSequence() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/reversedEmptyBackSequence.kt"); + } + + @Test + @TestMetadata("reversedEmptyRange.kt") + public void testReversedEmptyRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/reversedEmptyRange.kt"); + } + + @Test + @TestMetadata("reversedInexactSteppedDownTo.kt") + public void testReversedInexactSteppedDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/reversedInexactSteppedDownTo.kt"); + } + + @Test + @TestMetadata("reversedRange.kt") + public void testReversedRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/reversedRange.kt"); + } + + @Test + @TestMetadata("reversedSimpleSteppedRange.kt") + public void testReversedSimpleSteppedRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/reversedSimpleSteppedRange.kt"); + } + + @Test + @TestMetadata("simpleDownTo.kt") + public void testSimpleDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/simpleDownTo.kt"); + } + + @Test + @TestMetadata("simpleRange.kt") + public void testSimpleRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/simpleRange.kt"); + } + + @Test + @TestMetadata("simpleRangeWithNonConstantEnds.kt") + public void testSimpleRangeWithNonConstantEnds() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/simpleRangeWithNonConstantEnds.kt"); + } + + @Test + @TestMetadata("simpleSteppedDownTo.kt") + public void testSimpleSteppedDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/simpleSteppedDownTo.kt"); + } + + @Test + @TestMetadata("simpleSteppedRange.kt") + public void testSimpleSteppedRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/literal/simpleSteppedRange.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/nullableLoopParameter") + @TestDataPath("$PROJECT_ROOT") + public class NullableLoopParameter { + @Test + public void testAllFilesPresentInNullableLoopParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/nullableLoopParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("progressionExpression.kt") + public void testProgressionExpression() throws Exception { + runTest("compiler/testData/codegen/box/ranges/nullableLoopParameter/progressionExpression.kt"); + } + + @Test + @TestMetadata("rangeExpression.kt") + public void testRangeExpression() throws Exception { + runTest("compiler/testData/codegen/box/ranges/nullableLoopParameter/rangeExpression.kt"); + } + + @Test + @TestMetadata("rangeLiteral.kt") + public void testRangeLiteral() throws Exception { + runTest("compiler/testData/codegen/box/ranges/nullableLoopParameter/rangeLiteral.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped") + @TestDataPath("$PROJECT_ROOT") + public class Stepped { + @Test + public void testAllFilesPresentInStepped() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression") + @TestDataPath("$PROJECT_ROOT") + public class Expression { + @Test + public void testAllFilesPresentInExpression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/downTo") + @TestDataPath("$PROJECT_ROOT") + public class DownTo { + @Test + public void testAllFilesPresentInDownTo() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("emptyProgression.kt") + public void testEmptyProgression() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/emptyProgression.kt"); + } + + @Test + @TestMetadata("illegalStepNegative.kt") + public void testIllegalStepNegative() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/illegalStepNegative.kt"); + } + + @Test + @TestMetadata("illegalStepNonConst.kt") + public void testIllegalStepNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/illegalStepNonConst.kt"); + } + + @Test + @TestMetadata("illegalStepThenLegalStep.kt") + public void testIllegalStepThenLegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/illegalStepThenLegalStep.kt"); + } + + @Test + @TestMetadata("illegalStepZero.kt") + public void testIllegalStepZero() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/illegalStepZero.kt"); + } + + @Test + @TestMetadata("legalStepThenIllegalStep.kt") + public void testLegalStepThenIllegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/legalStepThenIllegalStep.kt"); + } + + @Test + @TestMetadata("maxValueToMinValueStepMaxValue.kt") + public void testMaxValueToMinValueStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/maxValueToMinValueStepMaxValue.kt"); + } + + @Test + @TestMetadata("maxValueToOneStepMaxValue.kt") + public void testMaxValueToOneStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/maxValueToOneStepMaxValue.kt"); + } + + @Test + @TestMetadata("maxValueToZeroStepMaxValue.kt") + public void testMaxValueToZeroStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/maxValueToZeroStepMaxValue.kt"); + } + + @Test + @TestMetadata("mixedTypeStep.kt") + public void testMixedTypeStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/mixedTypeStep.kt"); + } + + @Test + @TestMetadata("singleElementStepTwo.kt") + public void testSingleElementStepTwo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/singleElementStepTwo.kt"); + } + + @Test + @TestMetadata("stepNonConst.kt") + public void testStepNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/stepNonConst.kt"); + } + + @Test + @TestMetadata("stepOne.kt") + public void testStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/stepOne.kt"); + } + + @Test + @TestMetadata("stepToOutsideRange.kt") + public void testStepToOutsideRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/stepToOutsideRange.kt"); + } + + @Test + @TestMetadata("stepToSameLast.kt") + public void testStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/stepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLast.kt") + public void testStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/stepToSmallerLast.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep") + @TestDataPath("$PROJECT_ROOT") + public class NestedStep { + @Test + public void testAllFilesPresentInNestedStep() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("stepOneThenStepOne.kt") + public void testStepOneThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep/stepOneThenStepOne.kt"); + } + + @Test + @TestMetadata("stepThenSameStep.kt") + public void testStepThenSameStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep/stepThenSameStep.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepOne.kt") + public void testStepToSameLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep/stepToSameLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSameLast.kt") + public void testStepToSameLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep/stepToSameLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") + public void testStepToSameLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepOne.kt") + public void testStepToSmallerLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep/stepToSmallerLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") + public void testStepToSmallerLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") + public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed") + @TestDataPath("$PROJECT_ROOT") + public class Reversed { + @Test + public void testAllFilesPresentInReversed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("reversedThenStep.kt") + public void testReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed/reversedThenStep.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversed.kt") + public void testReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed/reversedThenStepThenReversed.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversedThenStep.kt") + public void testReversedThenStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed/reversedThenStepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversed.kt") + public void testStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed/stepThenReversed.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStep.kt") + public void testStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed/stepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStepThenReversed.kt") + public void testStepThenReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/downTo/reversed/stepThenReversedThenStepThenReversed.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo") + @TestDataPath("$PROJECT_ROOT") + public class RangeTo { + @Test + public void testAllFilesPresentInRangeTo() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("emptyProgression.kt") + public void testEmptyProgression() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/emptyProgression.kt"); + } + + @Test + @TestMetadata("illegalStepNegative.kt") + public void testIllegalStepNegative() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/illegalStepNegative.kt"); + } + + @Test + @TestMetadata("illegalStepNonConst.kt") + public void testIllegalStepNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/illegalStepNonConst.kt"); + } + + @Test + @TestMetadata("illegalStepThenLegalStep.kt") + public void testIllegalStepThenLegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/illegalStepThenLegalStep.kt"); + } + + @Test + @TestMetadata("illegalStepZero.kt") + public void testIllegalStepZero() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/illegalStepZero.kt"); + } + + @Test + @TestMetadata("legalStepThenIllegalStep.kt") + public void testLegalStepThenIllegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/legalStepThenIllegalStep.kt"); + } + + @Test + @TestMetadata("minValueToMaxValueStepMaxValue.kt") + public void testMinValueToMaxValueStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/minValueToMaxValueStepMaxValue.kt"); + } + + @Test + @TestMetadata("mixedTypeStep.kt") + public void testMixedTypeStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/mixedTypeStep.kt"); + } + + @Test + @TestMetadata("oneToMaxValueStepMaxValue.kt") + public void testOneToMaxValueStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/oneToMaxValueStepMaxValue.kt"); + } + + @Test + @TestMetadata("singleElementStepTwo.kt") + public void testSingleElementStepTwo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/singleElementStepTwo.kt"); + } + + @Test + @TestMetadata("stepNonConst.kt") + public void testStepNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/stepNonConst.kt"); + } + + @Test + @TestMetadata("stepOne.kt") + public void testStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/stepOne.kt"); + } + + @Test + @TestMetadata("stepToOutsideRange.kt") + public void testStepToOutsideRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/stepToOutsideRange.kt"); + } + + @Test + @TestMetadata("stepToSameLast.kt") + public void testStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/stepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLast.kt") + public void testStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/stepToSmallerLast.kt"); + } + + @Test + @TestMetadata("zeroToMaxValueStepMaxValue.kt") + public void testZeroToMaxValueStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/zeroToMaxValueStepMaxValue.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep") + @TestDataPath("$PROJECT_ROOT") + public class NestedStep { + @Test + public void testAllFilesPresentInNestedStep() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("stepOneThenStepOne.kt") + public void testStepOneThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep/stepOneThenStepOne.kt"); + } + + @Test + @TestMetadata("stepThenSameStep.kt") + public void testStepThenSameStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep/stepThenSameStep.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepOne.kt") + public void testStepToSameLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep/stepToSameLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSameLast.kt") + public void testStepToSameLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep/stepToSameLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") + public void testStepToSameLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepOne.kt") + public void testStepToSmallerLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep/stepToSmallerLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") + public void testStepToSmallerLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") + public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed") + @TestDataPath("$PROJECT_ROOT") + public class Reversed { + @Test + public void testAllFilesPresentInReversed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("reversedThenStep.kt") + public void testReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed/reversedThenStep.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversed.kt") + public void testReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed/reversedThenStepThenReversed.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversedThenStep.kt") + public void testReversedThenStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed/reversedThenStepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversed.kt") + public void testStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed/stepThenReversed.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStep.kt") + public void testStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed/stepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStepThenReversed.kt") + public void testStepThenReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeTo/reversed/stepThenReversedThenStepThenReversed.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil") + @TestDataPath("$PROJECT_ROOT") + public class RangeUntil { + @Test + public void testAllFilesPresentInRangeUntil() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("emptyProgression.kt") + public void testEmptyProgression() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/emptyProgression.kt"); + } + + @Test + @TestMetadata("illegalStepNegative.kt") + public void testIllegalStepNegative() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/illegalStepNegative.kt"); + } + + @Test + @TestMetadata("illegalStepThenLegalStep.kt") + public void testIllegalStepThenLegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/illegalStepThenLegalStep.kt"); + } + + @Test + @TestMetadata("illegalStepZero.kt") + public void testIllegalStepZero() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/illegalStepZero.kt"); + } + + @Test + @TestMetadata("legalStepThenIllegalStep.kt") + public void testLegalStepThenIllegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/legalStepThenIllegalStep.kt"); + } + + @Test + @TestMetadata("singleElementStepTwo.kt") + public void testSingleElementStepTwo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/singleElementStepTwo.kt"); + } + + @Test + @TestMetadata("stepOne.kt") + public void testStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepOne.kt"); + } + + @Test + @TestMetadata("stepToOutsideRange.kt") + public void testStepToOutsideRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepToOutsideRange.kt"); + } + + @Test + @TestMetadata("stepToSameLast.kt") + public void testStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLast.kt") + public void testStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/stepToSmallerLast.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep") + @TestDataPath("$PROJECT_ROOT") + public class NestedStep { + @Test + public void testAllFilesPresentInNestedStep() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("stepOneThenStepOne.kt") + public void testStepOneThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepOneThenStepOne.kt"); + } + + @Test + @TestMetadata("stepThenSameStep.kt") + public void testStepThenSameStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepThenSameStep.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepOne.kt") + public void testStepToSameLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSameLast.kt") + public void testStepToSameLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") + public void testStepToSameLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepOne.kt") + public void testStepToSmallerLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") + public void testStepToSmallerLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") + public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed") + @TestDataPath("$PROJECT_ROOT") + public class Reversed { + @Test + public void testAllFilesPresentInReversed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("reversedThenStep.kt") + public void testReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/reversedThenStep.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversed.kt") + public void testReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/reversedThenStepThenReversed.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversedThenStep.kt") + public void testReversedThenStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversed.kt") + public void testStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/stepThenReversed.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStep.kt") + public void testStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/stepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStepThenReversed.kt") + public void testStepThenReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/until") + @TestDataPath("$PROJECT_ROOT") + public class Until { + @Test + public void testAllFilesPresentInUntil() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("emptyProgression.kt") + public void testEmptyProgression() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/emptyProgression.kt"); + } + + @Test + @TestMetadata("emptyProgressionToMinValue.kt") + public void testEmptyProgressionToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/emptyProgressionToMinValue.kt"); + } + + @Test + @TestMetadata("illegalStepNegative.kt") + public void testIllegalStepNegative() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/illegalStepNegative.kt"); + } + + @Test + @TestMetadata("illegalStepNonConst.kt") + public void testIllegalStepNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/illegalStepNonConst.kt"); + } + + @Test + @TestMetadata("illegalStepThenLegalStep.kt") + public void testIllegalStepThenLegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/illegalStepThenLegalStep.kt"); + } + + @Test + @TestMetadata("illegalStepZero.kt") + public void testIllegalStepZero() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/illegalStepZero.kt"); + } + + @Test + @TestMetadata("legalStepThenIllegalStep.kt") + public void testLegalStepThenIllegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/legalStepThenIllegalStep.kt"); + } + + @Test + @TestMetadata("minValueToMaxValueStepMaxValue.kt") + public void testMinValueToMaxValueStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/minValueToMaxValueStepMaxValue.kt"); + } + + @Test + @TestMetadata("mixedTypeStep.kt") + public void testMixedTypeStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/mixedTypeStep.kt"); + } + + @Test + @TestMetadata("progressionToNonConst.kt") + public void testProgressionToNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/progressionToNonConst.kt"); + } + + @Test + @TestMetadata("singleElementStepTwo.kt") + public void testSingleElementStepTwo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/singleElementStepTwo.kt"); + } + + @Test + @TestMetadata("stepNonConst.kt") + public void testStepNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/stepNonConst.kt"); + } + + @Test + @TestMetadata("stepOne.kt") + public void testStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/stepOne.kt"); + } + + @Test + @TestMetadata("stepToOutsideRange.kt") + public void testStepToOutsideRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/stepToOutsideRange.kt"); + } + + @Test + @TestMetadata("stepToSameLast.kt") + public void testStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/stepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLast.kt") + public void testStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/stepToSmallerLast.kt"); + } + + @Test + @TestMetadata("zeroToMaxValueStepMaxValue.kt") + public void testZeroToMaxValueStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/zeroToMaxValueStepMaxValue.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep") + @TestDataPath("$PROJECT_ROOT") + public class NestedStep { + @Test + public void testAllFilesPresentInNestedStep() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("stepOneThenStepOne.kt") + public void testStepOneThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep/stepOneThenStepOne.kt"); + } + + @Test + @TestMetadata("stepThenSameStep.kt") + public void testStepThenSameStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep/stepThenSameStep.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepOne.kt") + public void testStepToSameLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep/stepToSameLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSameLast.kt") + public void testStepToSameLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep/stepToSameLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") + public void testStepToSameLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepOne.kt") + public void testStepToSmallerLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep/stepToSmallerLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") + public void testStepToSmallerLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") + public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed") + @TestDataPath("$PROJECT_ROOT") + public class Reversed { + @Test + public void testAllFilesPresentInReversed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("reversedThenStep.kt") + public void testReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed/reversedThenStep.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversed.kt") + public void testReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed/reversedThenStepThenReversed.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversedThenStep.kt") + public void testReversedThenStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed/reversedThenStepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversed.kt") + public void testStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed/stepThenReversed.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStep.kt") + public void testStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed/stepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStepThenReversed.kt") + public void testStepThenReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/expression/until/reversed/stepThenReversedThenStepThenReversed.kt"); + } + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal") + @TestDataPath("$PROJECT_ROOT") + public class Literal { + @Test + public void testAllFilesPresentInLiteral() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/downTo") + @TestDataPath("$PROJECT_ROOT") + public class DownTo { + @Test + public void testAllFilesPresentInDownTo() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("emptyProgression.kt") + public void testEmptyProgression() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/emptyProgression.kt"); + } + + @Test + @TestMetadata("illegalStepNegative.kt") + public void testIllegalStepNegative() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/illegalStepNegative.kt"); + } + + @Test + @TestMetadata("illegalStepNonConst.kt") + public void testIllegalStepNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/illegalStepNonConst.kt"); + } + + @Test + @TestMetadata("illegalStepThenLegalStep.kt") + public void testIllegalStepThenLegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/illegalStepThenLegalStep.kt"); + } + + @Test + @TestMetadata("illegalStepZero.kt") + public void testIllegalStepZero() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/illegalStepZero.kt"); + } + + @Test + @TestMetadata("legalStepThenIllegalStep.kt") + public void testLegalStepThenIllegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/legalStepThenIllegalStep.kt"); + } + + @Test + @TestMetadata("maxValueToMinValueStepMaxValue.kt") + public void testMaxValueToMinValueStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/maxValueToMinValueStepMaxValue.kt"); + } + + @Test + @TestMetadata("maxValueToOneStepMaxValue.kt") + public void testMaxValueToOneStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/maxValueToOneStepMaxValue.kt"); + } + + @Test + @TestMetadata("maxValueToZeroStepMaxValue.kt") + public void testMaxValueToZeroStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/maxValueToZeroStepMaxValue.kt"); + } + + @Test + @TestMetadata("mixedTypeStep.kt") + public void testMixedTypeStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/mixedTypeStep.kt"); + } + + @Test + @TestMetadata("singleElementStepTwo.kt") + public void testSingleElementStepTwo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/singleElementStepTwo.kt"); + } + + @Test + @TestMetadata("stepNonConst.kt") + public void testStepNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/stepNonConst.kt"); + } + + @Test + @TestMetadata("stepOne.kt") + public void testStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/stepOne.kt"); + } + + @Test + @TestMetadata("stepToOutsideRange.kt") + public void testStepToOutsideRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/stepToOutsideRange.kt"); + } + + @Test + @TestMetadata("stepToSameLast.kt") + public void testStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/stepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLast.kt") + public void testStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/stepToSmallerLast.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep") + @TestDataPath("$PROJECT_ROOT") + public class NestedStep { + @Test + public void testAllFilesPresentInNestedStep() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("stepOneThenStepOne.kt") + public void testStepOneThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep/stepOneThenStepOne.kt"); + } + + @Test + @TestMetadata("stepThenSameStep.kt") + public void testStepThenSameStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep/stepThenSameStep.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepOne.kt") + public void testStepToSameLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep/stepToSameLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSameLast.kt") + public void testStepToSameLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep/stepToSameLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") + public void testStepToSameLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepOne.kt") + public void testStepToSmallerLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep/stepToSmallerLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") + public void testStepToSmallerLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") + public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed") + @TestDataPath("$PROJECT_ROOT") + public class Reversed { + @Test + public void testAllFilesPresentInReversed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("reversedThenStep.kt") + public void testReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed/reversedThenStep.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversed.kt") + public void testReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed/reversedThenStepThenReversed.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversedThenStep.kt") + public void testReversedThenStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed/reversedThenStepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversed.kt") + public void testStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed/stepThenReversed.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStep.kt") + public void testStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed/stepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStepThenReversed.kt") + public void testStepThenReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/downTo/reversed/stepThenReversedThenStepThenReversed.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo") + @TestDataPath("$PROJECT_ROOT") + public class RangeTo { + @Test + public void testAllFilesPresentInRangeTo() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("emptyProgression.kt") + public void testEmptyProgression() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/emptyProgression.kt"); + } + + @Test + @TestMetadata("illegalStepNegative.kt") + public void testIllegalStepNegative() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/illegalStepNegative.kt"); + } + + @Test + @TestMetadata("illegalStepNonConst.kt") + public void testIllegalStepNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/illegalStepNonConst.kt"); + } + + @Test + @TestMetadata("illegalStepThenLegalStep.kt") + public void testIllegalStepThenLegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/illegalStepThenLegalStep.kt"); + } + + @Test + @TestMetadata("illegalStepZero.kt") + public void testIllegalStepZero() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/illegalStepZero.kt"); + } + + @Test + @TestMetadata("legalStepThenIllegalStep.kt") + public void testLegalStepThenIllegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/legalStepThenIllegalStep.kt"); + } + + @Test + @TestMetadata("minValueToMaxValueStepMaxValue.kt") + public void testMinValueToMaxValueStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/minValueToMaxValueStepMaxValue.kt"); + } + + @Test + @TestMetadata("mixedTypeStep.kt") + public void testMixedTypeStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/mixedTypeStep.kt"); + } + + @Test + @TestMetadata("oneToMaxValueStepMaxValue.kt") + public void testOneToMaxValueStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/oneToMaxValueStepMaxValue.kt"); + } + + @Test + @TestMetadata("singleElementStepTwo.kt") + public void testSingleElementStepTwo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/singleElementStepTwo.kt"); + } + + @Test + @TestMetadata("stepNonConst.kt") + public void testStepNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/stepNonConst.kt"); + } + + @Test + @TestMetadata("stepOne.kt") + public void testStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/stepOne.kt"); + } + + @Test + @TestMetadata("stepToOutsideRange.kt") + public void testStepToOutsideRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/stepToOutsideRange.kt"); + } + + @Test + @TestMetadata("stepToSameLast.kt") + public void testStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/stepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLast.kt") + public void testStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/stepToSmallerLast.kt"); + } + + @Test + @TestMetadata("zeroToMaxValueStepMaxValue.kt") + public void testZeroToMaxValueStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/zeroToMaxValueStepMaxValue.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep") + @TestDataPath("$PROJECT_ROOT") + public class NestedStep { + @Test + public void testAllFilesPresentInNestedStep() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("stepOneThenStepOne.kt") + public void testStepOneThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep/stepOneThenStepOne.kt"); + } + + @Test + @TestMetadata("stepThenSameStep.kt") + public void testStepThenSameStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep/stepThenSameStep.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepOne.kt") + public void testStepToSameLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep/stepToSameLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSameLast.kt") + public void testStepToSameLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep/stepToSameLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") + public void testStepToSameLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepOne.kt") + public void testStepToSmallerLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep/stepToSmallerLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") + public void testStepToSmallerLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") + public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed") + @TestDataPath("$PROJECT_ROOT") + public class Reversed { + @Test + public void testAllFilesPresentInReversed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("reversedThenStep.kt") + public void testReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed/reversedThenStep.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversed.kt") + public void testReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed/reversedThenStepThenReversed.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversedThenStep.kt") + public void testReversedThenStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed/reversedThenStepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversed.kt") + public void testStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed/stepThenReversed.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStep.kt") + public void testStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed/stepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStepThenReversed.kt") + public void testStepThenReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeTo/reversed/stepThenReversedThenStepThenReversed.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil") + @TestDataPath("$PROJECT_ROOT") + public class RangeUntil { + @Test + public void testAllFilesPresentInRangeUntil() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("emptyProgression.kt") + public void testEmptyProgression() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/emptyProgression.kt"); + } + + @Test + @TestMetadata("illegalStepNegative.kt") + public void testIllegalStepNegative() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/illegalStepNegative.kt"); + } + + @Test + @TestMetadata("illegalStepThenLegalStep.kt") + public void testIllegalStepThenLegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/illegalStepThenLegalStep.kt"); + } + + @Test + @TestMetadata("illegalStepZero.kt") + public void testIllegalStepZero() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/illegalStepZero.kt"); + } + + @Test + @TestMetadata("legalStepThenIllegalStep.kt") + public void testLegalStepThenIllegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/legalStepThenIllegalStep.kt"); + } + + @Test + @TestMetadata("singleElementStepTwo.kt") + public void testSingleElementStepTwo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/singleElementStepTwo.kt"); + } + + @Test + @TestMetadata("stepOne.kt") + public void testStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepOne.kt"); + } + + @Test + @TestMetadata("stepToOutsideRange.kt") + public void testStepToOutsideRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepToOutsideRange.kt"); + } + + @Test + @TestMetadata("stepToSameLast.kt") + public void testStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLast.kt") + public void testStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/stepToSmallerLast.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep") + @TestDataPath("$PROJECT_ROOT") + public class NestedStep { + @Test + public void testAllFilesPresentInNestedStep() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("stepOneThenStepOne.kt") + public void testStepOneThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepOneThenStepOne.kt"); + } + + @Test + @TestMetadata("stepThenSameStep.kt") + public void testStepThenSameStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepThenSameStep.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepOne.kt") + public void testStepToSameLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSameLast.kt") + public void testStepToSameLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") + public void testStepToSameLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepOne.kt") + public void testStepToSmallerLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") + public void testStepToSmallerLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") + public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed") + @TestDataPath("$PROJECT_ROOT") + public class Reversed { + @Test + public void testAllFilesPresentInReversed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("reversedThenStep.kt") + public void testReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/reversedThenStep.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversed.kt") + public void testReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/reversedThenStepThenReversed.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversedThenStep.kt") + public void testReversedThenStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversed.kt") + public void testStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/stepThenReversed.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStep.kt") + public void testStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/stepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStepThenReversed.kt") + public void testStepThenReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/until") + @TestDataPath("$PROJECT_ROOT") + public class Until { + @Test + public void testAllFilesPresentInUntil() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("emptyProgression.kt") + public void testEmptyProgression() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/emptyProgression.kt"); + } + + @Test + @TestMetadata("emptyProgressionToMinValue.kt") + public void testEmptyProgressionToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/emptyProgressionToMinValue.kt"); + } + + @Test + @TestMetadata("illegalStepNegative.kt") + public void testIllegalStepNegative() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/illegalStepNegative.kt"); + } + + @Test + @TestMetadata("illegalStepNonConst.kt") + public void testIllegalStepNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/illegalStepNonConst.kt"); + } + + @Test + @TestMetadata("illegalStepThenLegalStep.kt") + public void testIllegalStepThenLegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/illegalStepThenLegalStep.kt"); + } + + @Test + @TestMetadata("illegalStepZero.kt") + public void testIllegalStepZero() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/illegalStepZero.kt"); + } + + @Test + @TestMetadata("legalStepThenIllegalStep.kt") + public void testLegalStepThenIllegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/legalStepThenIllegalStep.kt"); + } + + @Test + @TestMetadata("minValueToMaxValueStepMaxValue.kt") + public void testMinValueToMaxValueStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/minValueToMaxValueStepMaxValue.kt"); + } + + @Test + @TestMetadata("mixedTypeStep.kt") + public void testMixedTypeStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/mixedTypeStep.kt"); + } + + @Test + @TestMetadata("progressionToNonConst.kt") + public void testProgressionToNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/progressionToNonConst.kt"); + } + + @Test + @TestMetadata("singleElementStepTwo.kt") + public void testSingleElementStepTwo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/singleElementStepTwo.kt"); + } + + @Test + @TestMetadata("stepNonConst.kt") + public void testStepNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/stepNonConst.kt"); + } + + @Test + @TestMetadata("stepOne.kt") + public void testStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/stepOne.kt"); + } + + @Test + @TestMetadata("stepToOutsideRange.kt") + public void testStepToOutsideRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/stepToOutsideRange.kt"); + } + + @Test + @TestMetadata("stepToSameLast.kt") + public void testStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/stepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLast.kt") + public void testStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/stepToSmallerLast.kt"); + } + + @Test + @TestMetadata("zeroToMaxValueStepMaxValue.kt") + public void testZeroToMaxValueStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/zeroToMaxValueStepMaxValue.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep") + @TestDataPath("$PROJECT_ROOT") + public class NestedStep { + @Test + public void testAllFilesPresentInNestedStep() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("stepOneThenStepOne.kt") + public void testStepOneThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep/stepOneThenStepOne.kt"); + } + + @Test + @TestMetadata("stepThenSameStep.kt") + public void testStepThenSameStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep/stepThenSameStep.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepOne.kt") + public void testStepToSameLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep/stepToSameLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSameLast.kt") + public void testStepToSameLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep/stepToSameLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") + public void testStepToSameLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepOne.kt") + public void testStepToSmallerLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep/stepToSmallerLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") + public void testStepToSmallerLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") + public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed") + @TestDataPath("$PROJECT_ROOT") + public class Reversed { + @Test + public void testAllFilesPresentInReversed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("reversedThenStep.kt") + public void testReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed/reversedThenStep.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversed.kt") + public void testReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed/reversedThenStepThenReversed.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversedThenStep.kt") + public void testReversedThenStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed/reversedThenStepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversed.kt") + public void testStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed/stepThenReversed.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStep.kt") + public void testStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed/stepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStepThenReversed.kt") + public void testStepThenReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/literal/until/reversed/stepThenReversedThenStepThenReversed.kt"); + } + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned") + @TestDataPath("$PROJECT_ROOT") + public class Unsigned { + @Test + public void testAllFilesPresentInUnsigned() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression") + @TestDataPath("$PROJECT_ROOT") + public class Expression { + @Test + public void testAllFilesPresentInExpression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo") + @TestDataPath("$PROJECT_ROOT") + public class DownTo { + @Test + public void testAllFilesPresentInDownTo() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("emptyProgression.kt") + public void testEmptyProgression() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/emptyProgression.kt"); + } + + @Test + @TestMetadata("illegalStepNegative.kt") + public void testIllegalStepNegative() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/illegalStepNegative.kt"); + } + + @Test + @TestMetadata("illegalStepNonConst.kt") + public void testIllegalStepNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/illegalStepNonConst.kt"); + } + + @Test + @TestMetadata("illegalStepThenLegalStep.kt") + public void testIllegalStepThenLegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/illegalStepThenLegalStep.kt"); + } + + @Test + @TestMetadata("illegalStepZero.kt") + public void testIllegalStepZero() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/illegalStepZero.kt"); + } + + @Test + @TestMetadata("legalStepThenIllegalStep.kt") + public void testLegalStepThenIllegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/legalStepThenIllegalStep.kt"); + } + + @Test + @TestMetadata("maxValueToMinValueStepMaxValue.kt") + public void testMaxValueToMinValueStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/maxValueToMinValueStepMaxValue.kt"); + } + + @Test + @TestMetadata("maxValueToOneStepMaxValue.kt") + public void testMaxValueToOneStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/maxValueToOneStepMaxValue.kt"); + } + + @Test + @TestMetadata("maxValueToZeroStepMaxValue.kt") + public void testMaxValueToZeroStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/maxValueToZeroStepMaxValue.kt"); + } + + @Test + @TestMetadata("mixedTypeStep.kt") + public void testMixedTypeStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/mixedTypeStep.kt"); + } + + @Test + @TestMetadata("singleElementStepTwo.kt") + public void testSingleElementStepTwo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/singleElementStepTwo.kt"); + } + + @Test + @TestMetadata("stepNonConst.kt") + public void testStepNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/stepNonConst.kt"); + } + + @Test + @TestMetadata("stepOne.kt") + public void testStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/stepOne.kt"); + } + + @Test + @TestMetadata("stepToOutsideRange.kt") + public void testStepToOutsideRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/stepToOutsideRange.kt"); + } + + @Test + @TestMetadata("stepToSameLast.kt") + public void testStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/stepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLast.kt") + public void testStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/stepToSmallerLast.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep") + @TestDataPath("$PROJECT_ROOT") + public class NestedStep { + @Test + public void testAllFilesPresentInNestedStep() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("stepOneThenStepOne.kt") + public void testStepOneThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep/stepOneThenStepOne.kt"); + } + + @Test + @TestMetadata("stepThenSameStep.kt") + public void testStepThenSameStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep/stepThenSameStep.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepOne.kt") + public void testStepToSameLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep/stepToSameLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSameLast.kt") + public void testStepToSameLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep/stepToSameLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") + public void testStepToSameLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepOne.kt") + public void testStepToSmallerLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep/stepToSmallerLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") + public void testStepToSmallerLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") + public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed") + @TestDataPath("$PROJECT_ROOT") + public class Reversed { + @Test + public void testAllFilesPresentInReversed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("reversedThenStep.kt") + public void testReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed/reversedThenStep.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversed.kt") + public void testReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed/reversedThenStepThenReversed.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversedThenStep.kt") + public void testReversedThenStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed/reversedThenStepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversed.kt") + public void testStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed/stepThenReversed.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStep.kt") + public void testStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed/stepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStepThenReversed.kt") + public void testStepThenReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/downTo/reversed/stepThenReversedThenStepThenReversed.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo") + @TestDataPath("$PROJECT_ROOT") + public class RangeTo { + @Test + public void testAllFilesPresentInRangeTo() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("emptyProgression.kt") + public void testEmptyProgression() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/emptyProgression.kt"); + } + + @Test + @TestMetadata("illegalStepNegative.kt") + public void testIllegalStepNegative() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/illegalStepNegative.kt"); + } + + @Test + @TestMetadata("illegalStepNonConst.kt") + public void testIllegalStepNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/illegalStepNonConst.kt"); + } + + @Test + @TestMetadata("illegalStepThenLegalStep.kt") + public void testIllegalStepThenLegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/illegalStepThenLegalStep.kt"); + } + + @Test + @TestMetadata("illegalStepZero.kt") + public void testIllegalStepZero() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/illegalStepZero.kt"); + } + + @Test + @TestMetadata("legalStepThenIllegalStep.kt") + public void testLegalStepThenIllegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/legalStepThenIllegalStep.kt"); + } + + @Test + @TestMetadata("minValueToMaxValueStepMaxValue.kt") + public void testMinValueToMaxValueStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/minValueToMaxValueStepMaxValue.kt"); + } + + @Test + @TestMetadata("mixedTypeStep.kt") + public void testMixedTypeStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/mixedTypeStep.kt"); + } + + @Test + @TestMetadata("oneToMaxValueStepMaxValue.kt") + public void testOneToMaxValueStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/oneToMaxValueStepMaxValue.kt"); + } + + @Test + @TestMetadata("singleElementStepTwo.kt") + public void testSingleElementStepTwo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/singleElementStepTwo.kt"); + } + + @Test + @TestMetadata("stepNonConst.kt") + public void testStepNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/stepNonConst.kt"); + } + + @Test + @TestMetadata("stepOne.kt") + public void testStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/stepOne.kt"); + } + + @Test + @TestMetadata("stepToOutsideRange.kt") + public void testStepToOutsideRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/stepToOutsideRange.kt"); + } + + @Test + @TestMetadata("stepToSameLast.kt") + public void testStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/stepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLast.kt") + public void testStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/stepToSmallerLast.kt"); + } + + @Test + @TestMetadata("zeroToMaxValueStepMaxValue.kt") + public void testZeroToMaxValueStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/zeroToMaxValueStepMaxValue.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep") + @TestDataPath("$PROJECT_ROOT") + public class NestedStep { + @Test + public void testAllFilesPresentInNestedStep() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("stepOneThenStepOne.kt") + public void testStepOneThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep/stepOneThenStepOne.kt"); + } + + @Test + @TestMetadata("stepThenSameStep.kt") + public void testStepThenSameStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep/stepThenSameStep.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepOne.kt") + public void testStepToSameLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep/stepToSameLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSameLast.kt") + public void testStepToSameLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep/stepToSameLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") + public void testStepToSameLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepOne.kt") + public void testStepToSmallerLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep/stepToSmallerLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") + public void testStepToSmallerLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") + public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed") + @TestDataPath("$PROJECT_ROOT") + public class Reversed { + @Test + public void testAllFilesPresentInReversed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("reversedThenStep.kt") + public void testReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed/reversedThenStep.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversed.kt") + public void testReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed/reversedThenStepThenReversed.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversedThenStep.kt") + public void testReversedThenStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed/reversedThenStepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversed.kt") + public void testStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed/stepThenReversed.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStep.kt") + public void testStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed/stepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStepThenReversed.kt") + public void testStepThenReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeTo/reversed/stepThenReversedThenStepThenReversed.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil") + @TestDataPath("$PROJECT_ROOT") + public class RangeUntil { + @Test + public void testAllFilesPresentInRangeUntil() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("emptyProgression.kt") + public void testEmptyProgression() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/emptyProgression.kt"); + } + + @Test + @TestMetadata("illegalStepNegative.kt") + public void testIllegalStepNegative() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/illegalStepNegative.kt"); + } + + @Test + @TestMetadata("illegalStepThenLegalStep.kt") + public void testIllegalStepThenLegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/illegalStepThenLegalStep.kt"); + } + + @Test + @TestMetadata("illegalStepZero.kt") + public void testIllegalStepZero() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/illegalStepZero.kt"); + } + + @Test + @TestMetadata("legalStepThenIllegalStep.kt") + public void testLegalStepThenIllegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/legalStepThenIllegalStep.kt"); + } + + @Test + @TestMetadata("singleElementStepTwo.kt") + public void testSingleElementStepTwo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/singleElementStepTwo.kt"); + } + + @Test + @TestMetadata("stepOne.kt") + public void testStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepOne.kt"); + } + + @Test + @TestMetadata("stepToOutsideRange.kt") + public void testStepToOutsideRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepToOutsideRange.kt"); + } + + @Test + @TestMetadata("stepToSameLast.kt") + public void testStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLast.kt") + public void testStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/stepToSmallerLast.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep") + @TestDataPath("$PROJECT_ROOT") + public class NestedStep { + @Test + public void testAllFilesPresentInNestedStep() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("stepOneThenStepOne.kt") + public void testStepOneThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepOneThenStepOne.kt"); + } + + @Test + @TestMetadata("stepThenSameStep.kt") + public void testStepThenSameStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepThenSameStep.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepOne.kt") + public void testStepToSameLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSameLast.kt") + public void testStepToSameLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") + public void testStepToSameLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepOne.kt") + public void testStepToSmallerLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") + public void testStepToSmallerLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") + public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed") + @TestDataPath("$PROJECT_ROOT") + public class Reversed { + @Test + public void testAllFilesPresentInReversed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("reversedThenStep.kt") + public void testReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/reversedThenStep.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversed.kt") + public void testReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/reversedThenStepThenReversed.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversedThenStep.kt") + public void testReversedThenStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversed.kt") + public void testStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/stepThenReversed.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStep.kt") + public void testStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/stepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStepThenReversed.kt") + public void testStepThenReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until") + @TestDataPath("$PROJECT_ROOT") + public class Until { + @Test + public void testAllFilesPresentInUntil() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("emptyProgression.kt") + public void testEmptyProgression() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/emptyProgression.kt"); + } + + @Test + @TestMetadata("emptyProgressionToMinValue.kt") + public void testEmptyProgressionToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/emptyProgressionToMinValue.kt"); + } + + @Test + @TestMetadata("illegalStepNegative.kt") + public void testIllegalStepNegative() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/illegalStepNegative.kt"); + } + + @Test + @TestMetadata("illegalStepNonConst.kt") + public void testIllegalStepNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/illegalStepNonConst.kt"); + } + + @Test + @TestMetadata("illegalStepThenLegalStep.kt") + public void testIllegalStepThenLegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/illegalStepThenLegalStep.kt"); + } + + @Test + @TestMetadata("illegalStepZero.kt") + public void testIllegalStepZero() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/illegalStepZero.kt"); + } + + @Test + @TestMetadata("legalStepThenIllegalStep.kt") + public void testLegalStepThenIllegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/legalStepThenIllegalStep.kt"); + } + + @Test + @TestMetadata("minValueToMaxValueStepMaxValue.kt") + public void testMinValueToMaxValueStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/minValueToMaxValueStepMaxValue.kt"); + } + + @Test + @TestMetadata("mixedTypeStep.kt") + public void testMixedTypeStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/mixedTypeStep.kt"); + } + + @Test + @TestMetadata("progressionToNonConst.kt") + public void testProgressionToNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/progressionToNonConst.kt"); + } + + @Test + @TestMetadata("singleElementStepTwo.kt") + public void testSingleElementStepTwo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/singleElementStepTwo.kt"); + } + + @Test + @TestMetadata("stepNonConst.kt") + public void testStepNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/stepNonConst.kt"); + } + + @Test + @TestMetadata("stepOne.kt") + public void testStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/stepOne.kt"); + } + + @Test + @TestMetadata("stepToOutsideRange.kt") + public void testStepToOutsideRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/stepToOutsideRange.kt"); + } + + @Test + @TestMetadata("stepToSameLast.kt") + public void testStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/stepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLast.kt") + public void testStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/stepToSmallerLast.kt"); + } + + @Test + @TestMetadata("zeroToMaxValueStepMaxValue.kt") + public void testZeroToMaxValueStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/zeroToMaxValueStepMaxValue.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep") + @TestDataPath("$PROJECT_ROOT") + public class NestedStep { + @Test + public void testAllFilesPresentInNestedStep() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("stepOneThenStepOne.kt") + public void testStepOneThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep/stepOneThenStepOne.kt"); + } + + @Test + @TestMetadata("stepThenSameStep.kt") + public void testStepThenSameStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep/stepThenSameStep.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepOne.kt") + public void testStepToSameLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep/stepToSameLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSameLast.kt") + public void testStepToSameLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep/stepToSameLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") + public void testStepToSameLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepOne.kt") + public void testStepToSmallerLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep/stepToSmallerLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") + public void testStepToSmallerLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") + public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed") + @TestDataPath("$PROJECT_ROOT") + public class Reversed { + @Test + public void testAllFilesPresentInReversed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("reversedThenStep.kt") + public void testReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed/reversedThenStep.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversed.kt") + public void testReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed/reversedThenStepThenReversed.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversedThenStep.kt") + public void testReversedThenStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed/reversedThenStepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversed.kt") + public void testStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed/stepThenReversed.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStep.kt") + public void testStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed/stepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStepThenReversed.kt") + public void testStepThenReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/expression/until/reversed/stepThenReversedThenStepThenReversed.kt"); + } + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal") + @TestDataPath("$PROJECT_ROOT") + public class Literal { + @Test + public void testAllFilesPresentInLiteral() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo") + @TestDataPath("$PROJECT_ROOT") + public class DownTo { + @Test + public void testAllFilesPresentInDownTo() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("emptyProgression.kt") + public void testEmptyProgression() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/emptyProgression.kt"); + } + + @Test + @TestMetadata("illegalStepNegative.kt") + public void testIllegalStepNegative() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/illegalStepNegative.kt"); + } + + @Test + @TestMetadata("illegalStepNonConst.kt") + public void testIllegalStepNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/illegalStepNonConst.kt"); + } + + @Test + @TestMetadata("illegalStepThenLegalStep.kt") + public void testIllegalStepThenLegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/illegalStepThenLegalStep.kt"); + } + + @Test + @TestMetadata("illegalStepZero.kt") + public void testIllegalStepZero() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/illegalStepZero.kt"); + } + + @Test + @TestMetadata("legalStepThenIllegalStep.kt") + public void testLegalStepThenIllegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/legalStepThenIllegalStep.kt"); + } + + @Test + @TestMetadata("maxValueToMinValueStepMaxValue.kt") + public void testMaxValueToMinValueStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/maxValueToMinValueStepMaxValue.kt"); + } + + @Test + @TestMetadata("maxValueToOneStepMaxValue.kt") + public void testMaxValueToOneStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/maxValueToOneStepMaxValue.kt"); + } + + @Test + @TestMetadata("maxValueToZeroStepMaxValue.kt") + public void testMaxValueToZeroStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/maxValueToZeroStepMaxValue.kt"); + } + + @Test + @TestMetadata("mixedTypeStep.kt") + public void testMixedTypeStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/mixedTypeStep.kt"); + } + + @Test + @TestMetadata("singleElementStepTwo.kt") + public void testSingleElementStepTwo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/singleElementStepTwo.kt"); + } + + @Test + @TestMetadata("stepNonConst.kt") + public void testStepNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/stepNonConst.kt"); + } + + @Test + @TestMetadata("stepOne.kt") + public void testStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/stepOne.kt"); + } + + @Test + @TestMetadata("stepToOutsideRange.kt") + public void testStepToOutsideRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/stepToOutsideRange.kt"); + } + + @Test + @TestMetadata("stepToSameLast.kt") + public void testStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/stepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLast.kt") + public void testStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/stepToSmallerLast.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep") + @TestDataPath("$PROJECT_ROOT") + public class NestedStep { + @Test + public void testAllFilesPresentInNestedStep() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("stepOneThenStepOne.kt") + public void testStepOneThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep/stepOneThenStepOne.kt"); + } + + @Test + @TestMetadata("stepThenSameStep.kt") + public void testStepThenSameStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep/stepThenSameStep.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepOne.kt") + public void testStepToSameLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep/stepToSameLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSameLast.kt") + public void testStepToSameLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep/stepToSameLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") + public void testStepToSameLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepOne.kt") + public void testStepToSmallerLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep/stepToSmallerLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") + public void testStepToSmallerLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") + public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed") + @TestDataPath("$PROJECT_ROOT") + public class Reversed { + @Test + public void testAllFilesPresentInReversed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("reversedThenStep.kt") + public void testReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed/reversedThenStep.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversed.kt") + public void testReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed/reversedThenStepThenReversed.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversedThenStep.kt") + public void testReversedThenStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed/reversedThenStepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversed.kt") + public void testStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed/stepThenReversed.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStep.kt") + public void testStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed/stepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStepThenReversed.kt") + public void testStepThenReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/downTo/reversed/stepThenReversedThenStepThenReversed.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo") + @TestDataPath("$PROJECT_ROOT") + public class RangeTo { + @Test + public void testAllFilesPresentInRangeTo() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("emptyProgression.kt") + public void testEmptyProgression() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/emptyProgression.kt"); + } + + @Test + @TestMetadata("illegalStepNegative.kt") + public void testIllegalStepNegative() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/illegalStepNegative.kt"); + } + + @Test + @TestMetadata("illegalStepNonConst.kt") + public void testIllegalStepNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/illegalStepNonConst.kt"); + } + + @Test + @TestMetadata("illegalStepThenLegalStep.kt") + public void testIllegalStepThenLegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/illegalStepThenLegalStep.kt"); + } + + @Test + @TestMetadata("illegalStepZero.kt") + public void testIllegalStepZero() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/illegalStepZero.kt"); + } + + @Test + @TestMetadata("legalStepThenIllegalStep.kt") + public void testLegalStepThenIllegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/legalStepThenIllegalStep.kt"); + } + + @Test + @TestMetadata("minValueToMaxValueStepMaxValue.kt") + public void testMinValueToMaxValueStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/minValueToMaxValueStepMaxValue.kt"); + } + + @Test + @TestMetadata("mixedTypeStep.kt") + public void testMixedTypeStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/mixedTypeStep.kt"); + } + + @Test + @TestMetadata("oneToMaxValueStepMaxValue.kt") + public void testOneToMaxValueStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/oneToMaxValueStepMaxValue.kt"); + } + + @Test + @TestMetadata("singleElementStepTwo.kt") + public void testSingleElementStepTwo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/singleElementStepTwo.kt"); + } + + @Test + @TestMetadata("stepNonConst.kt") + public void testStepNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/stepNonConst.kt"); + } + + @Test + @TestMetadata("stepOne.kt") + public void testStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/stepOne.kt"); + } + + @Test + @TestMetadata("stepToOutsideRange.kt") + public void testStepToOutsideRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/stepToOutsideRange.kt"); + } + + @Test + @TestMetadata("stepToSameLast.kt") + public void testStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/stepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLast.kt") + public void testStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/stepToSmallerLast.kt"); + } + + @Test + @TestMetadata("zeroToMaxValueStepMaxValue.kt") + public void testZeroToMaxValueStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/zeroToMaxValueStepMaxValue.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep") + @TestDataPath("$PROJECT_ROOT") + public class NestedStep { + @Test + public void testAllFilesPresentInNestedStep() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("stepOneThenStepOne.kt") + public void testStepOneThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep/stepOneThenStepOne.kt"); + } + + @Test + @TestMetadata("stepThenSameStep.kt") + public void testStepThenSameStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep/stepThenSameStep.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepOne.kt") + public void testStepToSameLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep/stepToSameLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSameLast.kt") + public void testStepToSameLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep/stepToSameLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") + public void testStepToSameLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepOne.kt") + public void testStepToSmallerLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep/stepToSmallerLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") + public void testStepToSmallerLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") + public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed") + @TestDataPath("$PROJECT_ROOT") + public class Reversed { + @Test + public void testAllFilesPresentInReversed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("reversedThenStep.kt") + public void testReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed/reversedThenStep.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversed.kt") + public void testReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed/reversedThenStepThenReversed.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversedThenStep.kt") + public void testReversedThenStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed/reversedThenStepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversed.kt") + public void testStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed/stepThenReversed.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStep.kt") + public void testStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed/stepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStepThenReversed.kt") + public void testStepThenReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeTo/reversed/stepThenReversedThenStepThenReversed.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil") + @TestDataPath("$PROJECT_ROOT") + public class RangeUntil { + @Test + public void testAllFilesPresentInRangeUntil() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("emptyProgression.kt") + public void testEmptyProgression() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/emptyProgression.kt"); + } + + @Test + @TestMetadata("illegalStepNegative.kt") + public void testIllegalStepNegative() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/illegalStepNegative.kt"); + } + + @Test + @TestMetadata("illegalStepThenLegalStep.kt") + public void testIllegalStepThenLegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/illegalStepThenLegalStep.kt"); + } + + @Test + @TestMetadata("illegalStepZero.kt") + public void testIllegalStepZero() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/illegalStepZero.kt"); + } + + @Test + @TestMetadata("legalStepThenIllegalStep.kt") + public void testLegalStepThenIllegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/legalStepThenIllegalStep.kt"); + } + + @Test + @TestMetadata("singleElementStepTwo.kt") + public void testSingleElementStepTwo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/singleElementStepTwo.kt"); + } + + @Test + @TestMetadata("stepOne.kt") + public void testStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepOne.kt"); + } + + @Test + @TestMetadata("stepToOutsideRange.kt") + public void testStepToOutsideRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepToOutsideRange.kt"); + } + + @Test + @TestMetadata("stepToSameLast.kt") + public void testStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLast.kt") + public void testStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/stepToSmallerLast.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep") + @TestDataPath("$PROJECT_ROOT") + public class NestedStep { + @Test + public void testAllFilesPresentInNestedStep() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("stepOneThenStepOne.kt") + public void testStepOneThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepOneThenStepOne.kt"); + } + + @Test + @TestMetadata("stepThenSameStep.kt") + public void testStepThenSameStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepThenSameStep.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepOne.kt") + public void testStepToSameLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSameLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSameLast.kt") + public void testStepToSameLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") + public void testStepToSameLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepOne.kt") + public void testStepToSmallerLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") + public void testStepToSmallerLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") + public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed") + @TestDataPath("$PROJECT_ROOT") + public class Reversed { + @Test + public void testAllFilesPresentInReversed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("reversedThenStep.kt") + public void testReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/reversedThenStep.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversed.kt") + public void testReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/reversedThenStepThenReversed.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversedThenStep.kt") + public void testReversedThenStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/reversedThenStepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversed.kt") + public void testStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/stepThenReversed.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStep.kt") + public void testStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/stepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStepThenReversed.kt") + public void testStepThenReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/rangeUntil/reversed/stepThenReversedThenStepThenReversed.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until") + @TestDataPath("$PROJECT_ROOT") + public class Until { + @Test + public void testAllFilesPresentInUntil() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("emptyProgression.kt") + public void testEmptyProgression() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/emptyProgression.kt"); + } + + @Test + @TestMetadata("emptyProgressionToMinValue.kt") + public void testEmptyProgressionToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/emptyProgressionToMinValue.kt"); + } + + @Test + @TestMetadata("illegalStepNegative.kt") + public void testIllegalStepNegative() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/illegalStepNegative.kt"); + } + + @Test + @TestMetadata("illegalStepNonConst.kt") + public void testIllegalStepNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/illegalStepNonConst.kt"); + } + + @Test + @TestMetadata("illegalStepThenLegalStep.kt") + public void testIllegalStepThenLegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/illegalStepThenLegalStep.kt"); + } + + @Test + @TestMetadata("illegalStepZero.kt") + public void testIllegalStepZero() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/illegalStepZero.kt"); + } + + @Test + @TestMetadata("legalStepThenIllegalStep.kt") + public void testLegalStepThenIllegalStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/legalStepThenIllegalStep.kt"); + } + + @Test + @TestMetadata("minValueToMaxValueStepMaxValue.kt") + public void testMinValueToMaxValueStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/minValueToMaxValueStepMaxValue.kt"); + } + + @Test + @TestMetadata("mixedTypeStep.kt") + public void testMixedTypeStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/mixedTypeStep.kt"); + } + + @Test + @TestMetadata("progressionToNonConst.kt") + public void testProgressionToNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/progressionToNonConst.kt"); + } + + @Test + @TestMetadata("singleElementStepTwo.kt") + public void testSingleElementStepTwo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/singleElementStepTwo.kt"); + } + + @Test + @TestMetadata("stepNonConst.kt") + public void testStepNonConst() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/stepNonConst.kt"); + } + + @Test + @TestMetadata("stepOne.kt") + public void testStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/stepOne.kt"); + } + + @Test + @TestMetadata("stepToOutsideRange.kt") + public void testStepToOutsideRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/stepToOutsideRange.kt"); + } + + @Test + @TestMetadata("stepToSameLast.kt") + public void testStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/stepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLast.kt") + public void testStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/stepToSmallerLast.kt"); + } + + @Test + @TestMetadata("zeroToMaxValueStepMaxValue.kt") + public void testZeroToMaxValueStepMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/zeroToMaxValueStepMaxValue.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep") + @TestDataPath("$PROJECT_ROOT") + public class NestedStep { + @Test + public void testAllFilesPresentInNestedStep() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("stepOneThenStepOne.kt") + public void testStepOneThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep/stepOneThenStepOne.kt"); + } + + @Test + @TestMetadata("stepThenSameStep.kt") + public void testStepThenSameStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep/stepThenSameStep.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepOne.kt") + public void testStepToSameLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep/stepToSameLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSameLast.kt") + public void testStepToSameLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep/stepToSameLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSameLastThenStepToSmallerLast.kt") + public void testStepToSameLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep/stepToSameLastThenStepToSmallerLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepOne.kt") + public void testStepToSmallerLastThenStepOne() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep/stepToSmallerLastThenStepOne.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSameLast.kt") + public void testStepToSmallerLastThenStepToSameLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep/stepToSmallerLastThenStepToSameLast.kt"); + } + + @Test + @TestMetadata("stepToSmallerLastThenStepToSmallerLast.kt") + public void testStepToSmallerLastThenStepToSmallerLast() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/nestedStep/stepToSmallerLastThenStepToSmallerLast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed") + @TestDataPath("$PROJECT_ROOT") + public class Reversed { + @Test + public void testAllFilesPresentInReversed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("reversedThenStep.kt") + public void testReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed/reversedThenStep.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversed.kt") + public void testReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed/reversedThenStepThenReversed.kt"); + } + + @Test + @TestMetadata("reversedThenStepThenReversedThenStep.kt") + public void testReversedThenStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed/reversedThenStepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversed.kt") + public void testStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed/stepThenReversed.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStep.kt") + public void testStepThenReversedThenStep() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed/stepThenReversedThenStep.kt"); + } + + @Test + @TestMetadata("stepThenReversedThenStepThenReversed.kt") + public void testStepThenReversedThenStepThenReversed() throws Exception { + runTest("compiler/testData/codegen/box/ranges/stepped/unsigned/literal/until/reversed/stepThenReversedThenStepThenReversed.kt"); + } + } + } + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/unsigned") + @TestDataPath("$PROJECT_ROOT") + public class Unsigned { + @Test + public void testAllFilesPresentInUnsigned() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("bitShifting.kt") + public void testBitShifting() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/bitShifting.kt"); + } + + @Test + @TestMetadata("inMixedUnsignedRange.kt") + public void testInMixedUnsignedRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/inMixedUnsignedRange.kt"); + } + + @Test + @TestMetadata("kt35004.kt") + public void testKt35004() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/kt35004.kt"); + } + + @Test + @TestMetadata("kt36953.kt") + public void testKt36953() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/kt36953.kt"); + } + + @Test + @TestMetadata("kt36953_continue.kt") + public void testKt36953_continue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/kt36953_continue.kt"); + } + + @Test + @TestMetadata("outOfBoundsInMixedContains.kt") + public void testOutOfBoundsInMixedContains() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/outOfBoundsInMixedContains.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/unsigned/expression") + @TestDataPath("$PROJECT_ROOT") + public class Expression { + @Test + public void testAllFilesPresentInExpression() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/expression"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("emptyDownto.kt") + public void testEmptyDownto() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/emptyDownto.kt"); + } + + @Test + @TestMetadata("emptyRange.kt") + public void testEmptyRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/emptyRange.kt"); + } + + @Test + @TestMetadata("inexactDownToMinValue.kt") + public void testInexactDownToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/inexactDownToMinValue.kt"); + } + + @Test + @TestMetadata("inexactSteppedDownTo.kt") + public void testInexactSteppedDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/inexactSteppedDownTo.kt"); + } + + @Test + @TestMetadata("inexactSteppedRange.kt") + public void testInexactSteppedRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/inexactSteppedRange.kt"); + } + + @Test + @TestMetadata("inexactToMaxValue.kt") + public void testInexactToMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/inexactToMaxValue.kt"); + } + + @Test + @TestMetadata("maxValueMinusTwoToMaxValue.kt") + public void testMaxValueMinusTwoToMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/maxValueMinusTwoToMaxValue.kt"); + } + + @Test + @TestMetadata("maxValueToMaxValue.kt") + public void testMaxValueToMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/maxValueToMaxValue.kt"); + } + + @Test + @TestMetadata("maxValueToMinValue.kt") + public void testMaxValueToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/maxValueToMinValue.kt"); + } + + @Test + @TestMetadata("oneElementDownTo.kt") + public void testOneElementDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/oneElementDownTo.kt"); + } + + @Test + @TestMetadata("oneElementRange.kt") + public void testOneElementRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/oneElementRange.kt"); + } + + @Test + @TestMetadata("openRange.kt") + public void testOpenRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/openRange.kt"); + } + + @Test + @TestMetadata("openRangeUntil.kt") + public void testOpenRangeUntil() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/openRangeUntil.kt"); + } + + @Test + @TestMetadata("overflowZeroDownToMaxValue.kt") + public void testOverflowZeroDownToMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/overflowZeroDownToMaxValue.kt"); + } + + @Test + @TestMetadata("overflowZeroToMinValue.kt") + public void testOverflowZeroToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/overflowZeroToMinValue.kt"); + } + + @Test + @TestMetadata("progressionDownToMinValue.kt") + public void testProgressionDownToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/progressionDownToMinValue.kt"); + } + + @Test + @TestMetadata("progressionMaxValueMinusTwoToMaxValue.kt") + public void testProgressionMaxValueMinusTwoToMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/progressionMaxValueMinusTwoToMaxValue.kt"); + } + + @Test + @TestMetadata("progressionMaxValueToMaxValue.kt") + public void testProgressionMaxValueToMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/progressionMaxValueToMaxValue.kt"); + } + + @Test + @TestMetadata("progressionMaxValueToMinValue.kt") + public void testProgressionMaxValueToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/progressionMaxValueToMinValue.kt"); + } + + @Test + @TestMetadata("progressionMinValueToMinValue.kt") + public void testProgressionMinValueToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/progressionMinValueToMinValue.kt"); + } + + @Test + @TestMetadata("reversedBackSequence.kt") + public void testReversedBackSequence() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/reversedBackSequence.kt"); + } + + @Test + @TestMetadata("reversedEmptyBackSequence.kt") + public void testReversedEmptyBackSequence() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/reversedEmptyBackSequence.kt"); + } + + @Test + @TestMetadata("reversedEmptyRange.kt") + public void testReversedEmptyRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/reversedEmptyRange.kt"); + } + + @Test + @TestMetadata("reversedInexactSteppedDownTo.kt") + public void testReversedInexactSteppedDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/reversedInexactSteppedDownTo.kt"); + } + + @Test + @TestMetadata("reversedRange.kt") + public void testReversedRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/reversedRange.kt"); + } + + @Test + @TestMetadata("reversedSimpleSteppedRange.kt") + public void testReversedSimpleSteppedRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/reversedSimpleSteppedRange.kt"); + } + + @Test + @TestMetadata("simpleDownTo.kt") + public void testSimpleDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/simpleDownTo.kt"); + } + + @Test + @TestMetadata("simpleRange.kt") + public void testSimpleRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/simpleRange.kt"); + } + + @Test + @TestMetadata("simpleRangeWithNonConstantEnds.kt") + public void testSimpleRangeWithNonConstantEnds() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/simpleRangeWithNonConstantEnds.kt"); + } + + @Test + @TestMetadata("simpleSteppedDownTo.kt") + public void testSimpleSteppedDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/simpleSteppedDownTo.kt"); + } + + @Test + @TestMetadata("simpleSteppedRange.kt") + public void testSimpleSteppedRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/expression/simpleSteppedRange.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/unsigned/literal") + @TestDataPath("$PROJECT_ROOT") + public class Literal { + @Test + public void testAllFilesPresentInLiteral() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/literal"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("emptyDownto.kt") + public void testEmptyDownto() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/emptyDownto.kt"); + } + + @Test + @TestMetadata("emptyRange.kt") + public void testEmptyRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/emptyRange.kt"); + } + + @Test + @TestMetadata("inexactDownToMinValue.kt") + public void testInexactDownToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/inexactDownToMinValue.kt"); + } + + @Test + @TestMetadata("inexactSteppedDownTo.kt") + public void testInexactSteppedDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/inexactSteppedDownTo.kt"); + } + + @Test + @TestMetadata("inexactSteppedRange.kt") + public void testInexactSteppedRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/inexactSteppedRange.kt"); + } + + @Test + @TestMetadata("inexactToMaxValue.kt") + public void testInexactToMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/inexactToMaxValue.kt"); + } + + @Test + @TestMetadata("maxValueMinusTwoToMaxValue.kt") + public void testMaxValueMinusTwoToMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/maxValueMinusTwoToMaxValue.kt"); + } + + @Test + @TestMetadata("maxValueToMaxValue.kt") + public void testMaxValueToMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/maxValueToMaxValue.kt"); + } + + @Test + @TestMetadata("maxValueToMinValue.kt") + public void testMaxValueToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/maxValueToMinValue.kt"); + } + + @Test + @TestMetadata("oneElementDownTo.kt") + public void testOneElementDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/oneElementDownTo.kt"); + } + + @Test + @TestMetadata("oneElementRange.kt") + public void testOneElementRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/oneElementRange.kt"); + } + + @Test + @TestMetadata("openRange.kt") + public void testOpenRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/openRange.kt"); + } + + @Test + @TestMetadata("openRangeUntil.kt") + public void testOpenRangeUntil() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/openRangeUntil.kt"); + } + + @Test + @TestMetadata("overflowZeroDownToMaxValue.kt") + public void testOverflowZeroDownToMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/overflowZeroDownToMaxValue.kt"); + } + + @Test + @TestMetadata("overflowZeroToMinValue.kt") + public void testOverflowZeroToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/overflowZeroToMinValue.kt"); + } + + @Test + @TestMetadata("progressionDownToMinValue.kt") + public void testProgressionDownToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/progressionDownToMinValue.kt"); + } + + @Test + @TestMetadata("progressionMaxValueMinusTwoToMaxValue.kt") + public void testProgressionMaxValueMinusTwoToMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/progressionMaxValueMinusTwoToMaxValue.kt"); + } + + @Test + @TestMetadata("progressionMaxValueToMaxValue.kt") + public void testProgressionMaxValueToMaxValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/progressionMaxValueToMaxValue.kt"); + } + + @Test + @TestMetadata("progressionMaxValueToMinValue.kt") + public void testProgressionMaxValueToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/progressionMaxValueToMinValue.kt"); + } + + @Test + @TestMetadata("progressionMinValueToMinValue.kt") + public void testProgressionMinValueToMinValue() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/progressionMinValueToMinValue.kt"); + } + + @Test + @TestMetadata("reversedBackSequence.kt") + public void testReversedBackSequence() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/reversedBackSequence.kt"); + } + + @Test + @TestMetadata("reversedEmptyBackSequence.kt") + public void testReversedEmptyBackSequence() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/reversedEmptyBackSequence.kt"); + } + + @Test + @TestMetadata("reversedEmptyRange.kt") + public void testReversedEmptyRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/reversedEmptyRange.kt"); + } + + @Test + @TestMetadata("reversedInexactSteppedDownTo.kt") + public void testReversedInexactSteppedDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/reversedInexactSteppedDownTo.kt"); + } + + @Test + @TestMetadata("reversedRange.kt") + public void testReversedRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/reversedRange.kt"); + } + + @Test + @TestMetadata("reversedSimpleSteppedRange.kt") + public void testReversedSimpleSteppedRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/reversedSimpleSteppedRange.kt"); + } + + @Test + @TestMetadata("simpleDownTo.kt") + public void testSimpleDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/simpleDownTo.kt"); + } + + @Test + @TestMetadata("simpleRange.kt") + public void testSimpleRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/simpleRange.kt"); + } + + @Test + @TestMetadata("simpleRangeWithNonConstantEnds.kt") + public void testSimpleRangeWithNonConstantEnds() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/simpleRangeWithNonConstantEnds.kt"); + } + + @Test + @TestMetadata("simpleSteppedDownTo.kt") + public void testSimpleSteppedDownTo() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/simpleSteppedDownTo.kt"); + } + + @Test + @TestMetadata("simpleSteppedRange.kt") + public void testSimpleSteppedRange() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/literal/simpleSteppedRange.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter") + @TestDataPath("$PROJECT_ROOT") + public class NullableLoopParameter { + @Test + public void testAllFilesPresentInNullableLoopParameter() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("progressionExpression.kt") + public void testProgressionExpression() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter/progressionExpression.kt"); + } + + @Test + @TestMetadata("rangeExpression.kt") + public void testRangeExpression() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter/rangeExpression.kt"); + } + + @Test + @TestMetadata("rangeLiteral.kt") + public void testRangeLiteral() throws Exception { + runTest("compiler/testData/codegen/box/ranges/unsigned/nullableLoopParameter/rangeLiteral.kt"); + } + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/recursiveRawTypes") + @TestDataPath("$PROJECT_ROOT") + public class RecursiveRawTypes { + @Test + public void testAllFilesPresentInRecursiveRawTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/recursiveRawTypes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection") + @TestDataPath("$PROJECT_ROOT") + public class Reflection { + @Test + public void testAllFilesPresentInReflection() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/annotations") + @TestDataPath("$PROJECT_ROOT") + public class Annotations { + @Test + public void testAllFilesPresentInAnnotations() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/annotations/onTypes") + @TestDataPath("$PROJECT_ROOT") + public class OnTypes { + @Test + public void testAllFilesPresentInOnTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations/onTypes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/annotations/repeatable") + @TestDataPath("$PROJECT_ROOT") + public class Repeatable { + @Test + public void testAllFilesPresentInRepeatable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/annotations/repeatable"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/builtins") + @TestDataPath("$PROJECT_ROOT") + public class Builtins { + @Test + public void testAllFilesPresentInBuiltins() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/builtins"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/call") + @TestDataPath("$PROJECT_ROOT") + public class Call { + @Test + public void testAllFilesPresentInCall() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/call/bound") + @TestDataPath("$PROJECT_ROOT") + public class Bound { + @Test + public void testAllFilesPresentInBound() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/bound"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/call/inlineClasses") + @TestDataPath("$PROJECT_ROOT") + public class InlineClasses { + @Test + public void testAllFilesPresentInInlineClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/inlineClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/call/inlineClasses/nonNullObject") + @TestDataPath("$PROJECT_ROOT") + public class NonNullObject { + @Test + public void testAllFilesPresentInNonNullObject() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/inlineClasses/nonNullObject"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/call/inlineClasses/nullableObject") + @TestDataPath("$PROJECT_ROOT") + public class NullableObject { + @Test + public void testAllFilesPresentInNullableObject() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/inlineClasses/nullableObject"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/call/inlineClasses/primitive") + @TestDataPath("$PROJECT_ROOT") + public class Primitive { + @Test + public void testAllFilesPresentInPrimitive() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/inlineClasses/primitive"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/call/valueClasses") + @TestDataPath("$PROJECT_ROOT") + public class ValueClasses { + @Test + public void testAllFilesPresentInValueClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/call/valueClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/callBy") + @TestDataPath("$PROJECT_ROOT") + public class CallBy { + @Test + public void testAllFilesPresentInCallBy() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/callBy"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/classLiterals") + @TestDataPath("$PROJECT_ROOT") + public class ClassLiterals { + @Test + public void testAllFilesPresentInClassLiterals() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classLiterals"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("annotationClassLiteral.kt") + public void testAnnotationClassLiteral() throws Exception { + runTest("compiler/testData/codegen/box/reflection/classLiterals/annotationClassLiteral.kt"); + } + + @Test + @TestMetadata("genericClass.kt") + public void testGenericClass() throws Exception { + runTest("compiler/testData/codegen/box/reflection/classLiterals/genericClass.kt"); + } + + @Test + @TestMetadata("lambdaClass.kt") + public void testLambdaClass() throws Exception { + runTest("compiler/testData/codegen/box/reflection/classLiterals/lambdaClass.kt"); + } + + @Test + @TestMetadata("simpleClassLiteral.kt") + public void testSimpleClassLiteral() throws Exception { + runTest("compiler/testData/codegen/box/reflection/classLiterals/simpleClassLiteral.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/classes") + @TestDataPath("$PROJECT_ROOT") + public class Classes { + @Test + public void testAllFilesPresentInClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/classes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("localClassSimpleName.kt") + public void testLocalClassSimpleName() throws Exception { + runTest("compiler/testData/codegen/box/reflection/classes/localClassSimpleName.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/constructors") + @TestDataPath("$PROJECT_ROOT") + public class Constructors { + @Test + public void testAllFilesPresentInConstructors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/constructors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("constructorName.kt") + public void testConstructorName() throws Exception { + runTest("compiler/testData/codegen/box/reflection/constructors/constructorName.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/createAnnotation") + @TestDataPath("$PROJECT_ROOT") + public class CreateAnnotation { + @Test + public void testAllFilesPresentInCreateAnnotation() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/createAnnotation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/enclosing") + @TestDataPath("$PROJECT_ROOT") + public class Enclosing { + @Test + public void testAllFilesPresentInEnclosing() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/enclosing"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/functions") + @TestDataPath("$PROJECT_ROOT") + public class Functions { + @Test + public void testAllFilesPresentInFunctions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/functions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("genericOverriddenFunction.kt") + public void testGenericOverriddenFunction() throws Exception { + runTest("compiler/testData/codegen/box/reflection/functions/genericOverriddenFunction.kt"); + } + + @Test + @TestMetadata("simpleNames.kt") + public void testSimpleNames() throws Exception { + runTest("compiler/testData/codegen/box/reflection/functions/simpleNames.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/genericSignature") + @TestDataPath("$PROJECT_ROOT") + public class GenericSignature { + @Test + public void testAllFilesPresentInGenericSignature() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/genericSignature"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/isInstance") + @TestDataPath("$PROJECT_ROOT") + public class IsInstance { + @Test + public void testAllFilesPresentInIsInstance() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/isInstance"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/kClassInAnnotation") + @TestDataPath("$PROJECT_ROOT") + public class KClassInAnnotation { + @Test + public void testAllFilesPresentInKClassInAnnotation() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/kClassInAnnotation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/lambdaClasses") + @TestDataPath("$PROJECT_ROOT") + public class LambdaClasses { + @Test + public void testAllFilesPresentInLambdaClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/lambdaClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/mapping") + @TestDataPath("$PROJECT_ROOT") + public class Mapping { + @Test + public void testAllFilesPresentInMapping() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/mapping/fakeOverrides") + @TestDataPath("$PROJECT_ROOT") + public class FakeOverrides { + @Test + public void testAllFilesPresentInFakeOverrides() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/fakeOverrides"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/mapping/inlineClasses") + @TestDataPath("$PROJECT_ROOT") + public class InlineClasses { + @Test + public void testAllFilesPresentInInlineClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/inlineClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/mapping/jvmStatic") + @TestDataPath("$PROJECT_ROOT") + public class JvmStatic { + @Test + public void testAllFilesPresentInJvmStatic() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/jvmStatic"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/mapping/types") + @TestDataPath("$PROJECT_ROOT") + public class Types { + @Test + public void testAllFilesPresentInTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/types"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/mapping/valueClasses") + @TestDataPath("$PROJECT_ROOT") + public class ValueClasses { + @Test + public void testAllFilesPresentInValueClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/mapping/valueClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/methodsFromAny") + @TestDataPath("$PROJECT_ROOT") + public class MethodsFromAny { + @Test + public void testAllFilesPresentInMethodsFromAny() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/methodsFromAny"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("functionEqualsHashCode.kt") + public void testFunctionEqualsHashCode() throws Exception { + runTest("compiler/testData/codegen/box/reflection/methodsFromAny/functionEqualsHashCode.kt"); + } + + @Test + @TestMetadata("propertyEqualsHashCode.kt") + public void testPropertyEqualsHashCode() throws Exception { + runTest("compiler/testData/codegen/box/reflection/methodsFromAny/propertyEqualsHashCode.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/modifiers") + @TestDataPath("$PROJECT_ROOT") + public class Modifiers { + @Test + public void testAllFilesPresentInModifiers() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/modifiers"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/multifileClasses") + @TestDataPath("$PROJECT_ROOT") + public class MultifileClasses { + @Test + public void testAllFilesPresentInMultifileClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/multifileClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/noReflectAtRuntime") + @TestDataPath("$PROJECT_ROOT") + public class NoReflectAtRuntime { + @Test + public void testAllFilesPresentInNoReflectAtRuntime() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("propertyGetSetName.kt") + public void testPropertyGetSetName() throws Exception { + runTest("compiler/testData/codegen/box/reflection/noReflectAtRuntime/propertyGetSetName.kt"); + } + + @Test + @TestMetadata("propertyInstanceof.kt") + public void testPropertyInstanceof() throws Exception { + runTest("compiler/testData/codegen/box/reflection/noReflectAtRuntime/propertyInstanceof.kt"); + } + + @Test + @TestMetadata("simpleClassLiterals.kt") + public void testSimpleClassLiterals() throws Exception { + runTest("compiler/testData/codegen/box/reflection/noReflectAtRuntime/simpleClassLiterals.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/noReflectAtRuntime/methodsFromAny") + @TestDataPath("$PROJECT_ROOT") + public class MethodsFromAny { + @Test + public void testAllFilesPresentInMethodsFromAny() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/noReflectAtRuntime/methodsFromAny"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("delegatedProperty.kt") + public void testDelegatedProperty() throws Exception { + runTest("compiler/testData/codegen/box/reflection/noReflectAtRuntime/methodsFromAny/delegatedProperty.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/parameters") + @TestDataPath("$PROJECT_ROOT") + public class Parameters { + @Test + public void testAllFilesPresentInParameters() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/parameters"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/properties") + @TestDataPath("$PROJECT_ROOT") + public class Properties { + @Test + public void testAllFilesPresentInProperties() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("genericOverriddenProperty.kt") + public void testGenericOverriddenProperty() throws Exception { + runTest("compiler/testData/codegen/box/reflection/properties/genericOverriddenProperty.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/properties/accessors") + @TestDataPath("$PROJECT_ROOT") + public class Accessors { + @Test + public void testAllFilesPresentInAccessors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/accessors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/properties/getDelegate") + @TestDataPath("$PROJECT_ROOT") + public class GetDelegate { + @Test + public void testAllFilesPresentInGetDelegate() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/getDelegate"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/properties/getDelegate/method") + @TestDataPath("$PROJECT_ROOT") + public class Method { + @Test + public void testAllFilesPresentInMethod() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/getDelegate/method"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/properties/jvmField") + @TestDataPath("$PROJECT_ROOT") + public class JvmField { + @Test + public void testAllFilesPresentInJvmField() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/jvmField"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/properties/localDelegated") + @TestDataPath("$PROJECT_ROOT") + public class LocalDelegated { + @Test + public void testAllFilesPresentInLocalDelegated() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/properties/localDelegated"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/supertypes") + @TestDataPath("$PROJECT_ROOT") + public class Supertypes { + @Test + public void testAllFilesPresentInSupertypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/supertypes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/typeOf") + @TestDataPath("$PROJECT_ROOT") + public class TypeOf { + @Test + public void testAllFilesPresentInTypeOf() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("arrayOfNullableReified.kt") + public void testArrayOfNullableReified() throws Exception { + runTest("compiler/testData/codegen/box/reflection/typeOf/arrayOfNullableReified.kt"); + } + + @Test + @TestMetadata("classes.kt") + public void testClasses() throws Exception { + runTest("compiler/testData/codegen/box/reflection/typeOf/classes.kt"); + } + + @Test + @TestMetadata("inlineClasses.kt") + public void testInlineClasses() throws Exception { + runTest("compiler/testData/codegen/box/reflection/typeOf/inlineClasses.kt"); + } + + @Test + @TestMetadata("intersectionType.kt") + public void testIntersectionType() throws Exception { + runTest("compiler/testData/codegen/box/reflection/typeOf/intersectionType.kt"); + } + + @Test + @TestMetadata("manyTypeArguments.kt") + public void testManyTypeArguments() throws Exception { + runTest("compiler/testData/codegen/box/reflection/typeOf/manyTypeArguments.kt"); + } + + @Test + @TestMetadata("multipleLayers.kt") + public void testMultipleLayers() throws Exception { + runTest("compiler/testData/codegen/box/reflection/typeOf/multipleLayers.kt"); + } + + @Test + @TestMetadata("reifiedAsNestedArgument.kt") + public void testReifiedAsNestedArgument() throws Exception { + runTest("compiler/testData/codegen/box/reflection/typeOf/reifiedAsNestedArgument.kt"); + } + + @Test + @TestMetadata("typeOfCapturedStar.kt") + public void testTypeOfCapturedStar() throws Exception { + runTest("compiler/testData/codegen/box/reflection/typeOf/typeOfCapturedStar.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/typeOf/js") + @TestDataPath("$PROJECT_ROOT") + public class Js { + @Test + public void testAllFilesPresentInJs() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/js"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/typeOf/noReflect") + @TestDataPath("$PROJECT_ROOT") + public class NoReflect { + @Test + public void testAllFilesPresentInNoReflect() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("typeReferenceEqualsHashCode.kt") + public void testTypeReferenceEqualsHashCode() throws Exception { + runTest("compiler/testData/codegen/box/reflection/typeOf/noReflect/typeReferenceEqualsHashCode.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/typeOf/noReflect/nonReifiedTypeParameters") + @TestDataPath("$PROJECT_ROOT") + public class NonReifiedTypeParameters { + @Test + public void testAllFilesPresentInNonReifiedTypeParameters() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/noReflect/nonReifiedTypeParameters"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters") + @TestDataPath("$PROJECT_ROOT") + public class NonReifiedTypeParameters { + @Test + public void testAllFilesPresentInNonReifiedTypeParameters() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("defaultUpperBound.kt") + public void testDefaultUpperBound() throws Exception { + runTest("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters/defaultUpperBound.kt"); + } + + @Test + @TestMetadata("equalsOnClassParameters.kt") + public void testEqualsOnClassParameters() throws Exception { + runTest("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters/equalsOnClassParameters.kt"); + } + + @Test + @TestMetadata("equalsOnFunctionParameters.kt") + public void testEqualsOnFunctionParameters() throws Exception { + runTest("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters/equalsOnFunctionParameters.kt"); + } + + @Test + @TestMetadata("innerGeneric.kt") + public void testInnerGeneric() throws Exception { + runTest("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters/innerGeneric.kt"); + } + + @Test + @TestMetadata("simpleClassParameter.kt") + public void testSimpleClassParameter() throws Exception { + runTest("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters/simpleClassParameter.kt"); + } + + @Test + @TestMetadata("simpleFunctionParameter.kt") + public void testSimpleFunctionParameter() throws Exception { + runTest("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters/simpleFunctionParameter.kt"); + } + + @Test + @TestMetadata("simplePropertyParameter.kt") + public void testSimplePropertyParameter() throws Exception { + runTest("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters/simplePropertyParameter.kt"); + } + + @Test + @TestMetadata("starProjectionInUpperBound.kt") + public void testStarProjectionInUpperBound() throws Exception { + runTest("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters/starProjectionInUpperBound.kt"); + } + + @Test + @TestMetadata("typeParameterFlags.kt") + public void testTypeParameterFlags() throws Exception { + runTest("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters/typeParameterFlags.kt"); + } + + @Test + @TestMetadata("upperBoundUsesOuterClassParameter.kt") + public void testUpperBoundUsesOuterClassParameter() throws Exception { + runTest("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters/upperBoundUsesOuterClassParameter.kt"); + } + + @Test + @TestMetadata("upperBounds.kt") + public void testUpperBounds() throws Exception { + runTest("compiler/testData/codegen/box/reflection/typeOf/nonReifiedTypeParameters/upperBounds.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/typeParameters") + @TestDataPath("$PROJECT_ROOT") + public class TypeParameters { + @Test + public void testAllFilesPresentInTypeParameters() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/typeParameters"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/types") + @TestDataPath("$PROJECT_ROOT") + public class Types { + @Test + public void testAllFilesPresentInTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("innerGenericArguments.kt") + public void testInnerGenericArguments() throws Exception { + runTest("compiler/testData/codegen/box/reflection/types/innerGenericArguments.kt"); + } + + @Test + @TestMetadata("typeArguments.kt") + public void testTypeArguments() throws Exception { + runTest("compiler/testData/codegen/box/reflection/types/typeArguments.kt"); + } + + @Test + @TestMetadata("useSiteVariance.kt") + public void testUseSiteVariance() throws Exception { + runTest("compiler/testData/codegen/box/reflection/types/useSiteVariance.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/types/createType") + @TestDataPath("$PROJECT_ROOT") + public class CreateType { + @Test + public void testAllFilesPresentInCreateType() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/createType"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reflection/types/subtyping") + @TestDataPath("$PROJECT_ROOT") + public class Subtyping { + @Test + public void testAllFilesPresentInSubtyping() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reflection/types/subtyping"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/regressions") + @TestDataPath("$PROJECT_ROOT") + public class Regressions { + @Test + public void testAllFilesPresentInRegressions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/regressions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("arrayLengthNPE.kt") + public void testArrayLengthNPE() throws Exception { + runTest("compiler/testData/codegen/box/regressions/arrayLengthNPE.kt"); + } + + @Test + @TestMetadata("commonSupertypeContravariant.kt") + public void testCommonSupertypeContravariant() throws Exception { + runTest("compiler/testData/codegen/box/regressions/commonSupertypeContravariant.kt"); + } + + @Test + @TestMetadata("commonSupertypeContravariant2.kt") + public void testCommonSupertypeContravariant2() throws Exception { + runTest("compiler/testData/codegen/box/regressions/commonSupertypeContravariant2.kt"); + } + + @Test + @TestMetadata("dontCaptureTypesWithTypeVariables.kt") + public void testDontCaptureTypesWithTypeVariables() throws Exception { + runTest("compiler/testData/codegen/box/regressions/dontCaptureTypesWithTypeVariables.kt"); + } + + @Test + @TestMetadata("doubleMerge.kt") + public void testDoubleMerge() throws Exception { + runTest("compiler/testData/codegen/box/regressions/doubleMerge.kt"); + } + + @Test + @TestMetadata("floatMerge.kt") + public void testFloatMerge() throws Exception { + runTest("compiler/testData/codegen/box/regressions/floatMerge.kt"); + } + + @Test + @TestMetadata("functionLiteralAsLastExpressionInBlock.kt") + public void testFunctionLiteralAsLastExpressionInBlock() throws Exception { + runTest("compiler/testData/codegen/box/regressions/functionLiteralAsLastExpressionInBlock.kt"); + } + + @Test + @TestMetadata("generic.kt") + public void testGeneric() throws Exception { + runTest("compiler/testData/codegen/box/regressions/generic.kt"); + } + + @Test + @TestMetadata("hashCodeNPE.kt") + public void testHashCodeNPE() throws Exception { + runTest("compiler/testData/codegen/box/regressions/hashCodeNPE.kt"); + } + + @Test + @TestMetadata("internalTopLevelOtherPackage.kt") + public void testInternalTopLevelOtherPackage() throws Exception { + runTest("compiler/testData/codegen/box/regressions/internalTopLevelOtherPackage.kt"); + } + + @Test + @TestMetadata("intersectionOfEqualTypes.kt") + public void testIntersectionOfEqualTypes() throws Exception { + runTest("compiler/testData/codegen/box/regressions/intersectionOfEqualTypes.kt"); + } + + @Test + @TestMetadata("kt10143.kt") + public void testKt10143() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt10143.kt"); + } + + @Test + @TestMetadata("kt10934.kt") + public void testKt10934() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt10934.kt"); + } + + @Test + @TestMetadata("Kt1149.kt") + public void testKt1149() throws Exception { + runTest("compiler/testData/codegen/box/regressions/Kt1149.kt"); + } + + @Test + @TestMetadata("kt1172.kt") + public void testKt1172() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt1172.kt"); + } + + @Test + @TestMetadata("kt13381.kt") + public void testKt13381() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt13381.kt"); + } + + @Test + @TestMetadata("kt14447.kt") + public void testKt14447() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt14447.kt"); + } + + @Test + @TestMetadata("kt15196.kt") + public void testKt15196() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt15196.kt"); + } + + @Test + @TestMetadata("kt1528.kt") + public void testKt1528() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt1528.kt"); + } + + @Test + @TestMetadata("Kt1619Test.kt") + public void testKt1619Test() throws Exception { + runTest("compiler/testData/codegen/box/regressions/Kt1619Test.kt"); + } + + @Test + @TestMetadata("kt1779.kt") + public void testKt1779() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt1779.kt"); + } + + @Test + @TestMetadata("kt1800.kt") + public void testKt1800() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt1800.kt"); + } + + @Test + @TestMetadata("kt1845.kt") + public void testKt1845() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt1845.kt"); + } + + @Test + @TestMetadata("kt18779.kt") + public void testKt18779() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt18779.kt"); + } + + @Test + @TestMetadata("kt2017.kt") + public void testKt2017() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt2017.kt"); + } + + @Test + @TestMetadata("kt2060.kt") + public void testKt2060() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt2060.kt"); + } + + @Test + @TestMetadata("kt2210.kt") + public void testKt2210() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt2210.kt"); + } + + @Test + @TestMetadata("kt2246.kt") + public void testKt2246() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt2246.kt"); + } + + @Test + @TestMetadata("kt24913.kt") + public void testKt24913() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt24913.kt"); + } + + @Test + @TestMetadata("Kt2495Test.kt") + public void testKt2495Test() throws Exception { + runTest("compiler/testData/codegen/box/regressions/Kt2495Test.kt"); + } + + @Test + @TestMetadata("kt2509.kt") + public void testKt2509() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt2509.kt"); + } + + @Test + @TestMetadata("kt3107.kt") + public void testKt3107() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt3107.kt"); + } + + @Test + @TestMetadata("kt32949.kt") + public void testKt32949() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt32949.kt"); + } + + @Test + @TestMetadata("kt33638.kt") + public void testKt33638() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt33638.kt"); + } + + @Test + @TestMetadata("kt3421.kt") + public void testKt3421() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt3421.kt"); + } + + @Test + @TestMetadata("kt344.kt") + public void testKt344() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt344.kt"); + } + + @Test + @TestMetadata("kt3442.kt") + public void testKt3442() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt3442.kt"); + } + + @Test + @TestMetadata("kt3587.kt") + public void testKt3587() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt3587.kt"); + } + + @Test + @TestMetadata("kt35914.kt") + public void testKt35914() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt35914.kt"); + } + + @Test + @TestMetadata("kt3850.kt") + public void testKt3850() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt3850.kt"); + } + + @Test + @TestMetadata("kt3903.kt") + public void testKt3903() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt3903.kt"); + } + + @Test + @TestMetadata("kt39088.kt") + public void testKt39088() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt39088.kt"); + } + + @Test + @TestMetadata("kt4142.kt") + public void testKt4142() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt4142.kt"); + } + + @Test + @TestMetadata("kt4281.kt") + public void testKt4281() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt4281.kt"); + } + + @Test + @TestMetadata("kt47279.kt") + public void testKt47279() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt47279.kt"); + } + + @Test + @TestMetadata("kt5056.kt") + public void testKt5056() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt5056.kt"); + } + + @Test + @TestMetadata("kt5395.kt") + public void testKt5395() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt5395.kt"); + } + + @Test + @TestMetadata("kt57487.kt") + public void testKt57487() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt57487.kt"); + } + + @Test + @TestMetadata("kt5786_privateWithDefault.kt") + public void testKt5786_privateWithDefault() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt5786_privateWithDefault.kt"); + } + + @Test + @TestMetadata("kt5953.kt") + public void testKt5953() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt5953.kt"); + } + + @Test + @TestMetadata("kt6153.kt") + public void testKt6153() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt6153.kt"); + } + + @Test + @TestMetadata("kt6434.kt") + public void testKt6434() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt6434.kt"); + } + + @Test + @TestMetadata("kt6434_2.kt") + public void testKt6434_2() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt6434_2.kt"); + } + + @Test + @TestMetadata("kt7401.kt") + public void testKt7401() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt7401.kt"); + } + + @Test + @TestMetadata("kt789.kt") + public void testKt789() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt789.kt"); + } + + @Test + @TestMetadata("kt998.kt") + public void testKt998() throws Exception { + runTest("compiler/testData/codegen/box/regressions/kt998.kt"); + } + + @Test + @TestMetadata("lambdaAsLastExpressionInLambda.kt") + public void testLambdaAsLastExpressionInLambda() throws Exception { + runTest("compiler/testData/codegen/box/regressions/lambdaAsLastExpressionInLambda.kt"); + } + + @Test + @TestMetadata("lambdaPostponeConstruction.kt") + public void testLambdaPostponeConstruction() throws Exception { + runTest("compiler/testData/codegen/box/regressions/lambdaPostponeConstruction.kt"); + } + + @Test + @TestMetadata("lambdaWrongReturnType.kt") + public void testLambdaWrongReturnType() throws Exception { + runTest("compiler/testData/codegen/box/regressions/lambdaWrongReturnType.kt"); + } + + @Test + @TestMetadata("noAssertionsWhenNullableTypeParameterReplacedWithIntersectionType.kt") + public void testNoAssertionsWhenNullableTypeParameterReplacedWithIntersectionType() throws Exception { + runTest("compiler/testData/codegen/box/regressions/noAssertionsWhenNullableTypeParameterReplacedWithIntersectionType.kt"); + } + + @Test + @TestMetadata("noCapturingForTypesWithTypeVariables.kt") + public void testNoCapturingForTypesWithTypeVariables() throws Exception { + runTest("compiler/testData/codegen/box/regressions/noCapturingForTypesWithTypeVariables.kt"); + } + + @Test + @TestMetadata("noResolutionRecursion.kt") + public void testNoResolutionRecursion() throws Exception { + runTest("compiler/testData/codegen/box/regressions/noResolutionRecursion.kt"); + } + + @Test + @TestMetadata("nullabilityForCommonCapturedSupertypes.kt") + public void testNullabilityForCommonCapturedSupertypes() throws Exception { + runTest("compiler/testData/codegen/box/regressions/nullabilityForCommonCapturedSupertypes.kt"); + } + + @Test + @TestMetadata("nullableAfterExclExcl.kt") + public void testNullableAfterExclExcl() throws Exception { + runTest("compiler/testData/codegen/box/regressions/nullableAfterExclExcl.kt"); + } + + @Test + @TestMetadata("objectCaptureOuterConstructorProperty.kt") + public void testObjectCaptureOuterConstructorProperty() throws Exception { + runTest("compiler/testData/codegen/box/regressions/objectCaptureOuterConstructorProperty.kt"); + } + + @Test + @TestMetadata("objectInsideDelegation.kt") + public void testObjectInsideDelegation() throws Exception { + runTest("compiler/testData/codegen/box/regressions/objectInsideDelegation.kt"); + } + + @Test + @TestMetadata("recursiveDnnTypeInLambda.kt") + public void testRecursiveDnnTypeInLambda() throws Exception { + runTest("compiler/testData/codegen/box/regressions/recursiveDnnTypeInLambda.kt"); + } + + @Test + @TestMetadata("resolvedCallForGetOperator.kt") + public void testResolvedCallForGetOperator() throws Exception { + runTest("compiler/testData/codegen/box/regressions/resolvedCallForGetOperator.kt"); + } + + @Test + @TestMetadata("supertypeDepth.kt") + public void testSupertypeDepth() throws Exception { + runTest("compiler/testData/codegen/box/regressions/supertypeDepth.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reified") + @TestDataPath("$PROJECT_ROOT") + public class Reified { + @Test + public void testAllFilesPresentInReified() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("callableReferenceInlinedFun.kt") + public void testCallableReferenceInlinedFun() throws Exception { + runTest("compiler/testData/codegen/box/reified/callableReferenceInlinedFun.kt"); + } + + @Test + @TestMetadata("callableReferenceInlinedFunFromOtherModule.kt") + public void testCallableReferenceInlinedFunFromOtherModule() throws Exception { + runTest("compiler/testData/codegen/box/reified/callableReferenceInlinedFunFromOtherModule.kt"); + } + + @Test + @TestMetadata("checkcast.kt") + public void testCheckcast() throws Exception { + runTest("compiler/testData/codegen/box/reified/checkcast.kt"); + } + + @Test + @TestMetadata("copyToArray.kt") + public void testCopyToArray() throws Exception { + runTest("compiler/testData/codegen/box/reified/copyToArray.kt"); + } + + @Test + @TestMetadata("filterIsInstance.kt") + public void testFilterIsInstance() throws Exception { + runTest("compiler/testData/codegen/box/reified/filterIsInstance.kt"); + } + + @Test + @TestMetadata("instanceof.kt") + public void testInstanceof() throws Exception { + runTest("compiler/testData/codegen/box/reified/instanceof.kt"); + } + + @Test + @TestMetadata("kt16445.kt") + public void testKt16445() throws Exception { + runTest("compiler/testData/codegen/box/reified/kt16445.kt"); + } + + @Test + @TestMetadata("kt36237.kt") + public void testKt36237() throws Exception { + runTest("compiler/testData/codegen/box/reified/kt36237.kt"); + } + + @Test + @TestMetadata("kt39256_privateInlineWithAnonymousObject.kt") + public void testKt39256_privateInlineWithAnonymousObject() throws Exception { + runTest("compiler/testData/codegen/box/reified/kt39256_privateInlineWithAnonymousObject.kt"); + } + + @Test + @TestMetadata("newArrayInt.kt") + public void testNewArrayInt() throws Exception { + runTest("compiler/testData/codegen/box/reified/newArrayInt.kt"); + } + + @Test + @TestMetadata("recursiveNewArray.kt") + public void testRecursiveNewArray() throws Exception { + runTest("compiler/testData/codegen/box/reified/recursiveNewArray.kt"); + } + + @Test + @TestMetadata("reifiedChain.kt") + public void testReifiedChain() throws Exception { + runTest("compiler/testData/codegen/box/reified/reifiedChain.kt"); + } + + @Test + @TestMetadata("reifiedIntersectionType.kt") + public void testReifiedIntersectionType() throws Exception { + runTest("compiler/testData/codegen/box/reified/reifiedIntersectionType.kt"); + } + + @Test + @TestMetadata("reifiedIntersectionTypeArgument.kt") + public void testReifiedIntersectionTypeArgument() throws Exception { + runTest("compiler/testData/codegen/box/reified/reifiedIntersectionTypeArgument.kt"); + } + + @Test + @TestMetadata("reifiedIntersectionTypeArgumentCrossModule.kt") + public void testReifiedIntersectionTypeArgumentCrossModule() throws Exception { + runTest("compiler/testData/codegen/box/reified/reifiedIntersectionTypeArgumentCrossModule.kt"); + } + + @Test + @TestMetadata("reifiedTypeArgumentWithIntersectionTypeAsTypeArgument.kt") + public void testReifiedTypeArgumentWithIntersectionTypeAsTypeArgument() throws Exception { + runTest("compiler/testData/codegen/box/reified/reifiedTypeArgumentWithIntersectionTypeAsTypeArgument.kt"); + } + + @Test + @TestMetadata("reifiedTypeArgumentWithRecursion.kt") + public void testReifiedTypeArgumentWithRecursion() throws Exception { + runTest("compiler/testData/codegen/box/reified/reifiedTypeArgumentWithRecursion.kt"); + } + + @Test + @TestMetadata("safecast.kt") + public void testSafecast() throws Exception { + runTest("compiler/testData/codegen/box/reified/safecast.kt"); + } + + @Test + @TestMetadata("sameIndexRecursive.kt") + public void testSameIndexRecursive() throws Exception { + runTest("compiler/testData/codegen/box/reified/sameIndexRecursive.kt"); + } + + @Test + @TestMetadata("spreads.kt") + public void testSpreads() throws Exception { + runTest("compiler/testData/codegen/box/reified/spreads.kt"); + } + + @Test + @TestMetadata("varargs.kt") + public void testVarargs() throws Exception { + runTest("compiler/testData/codegen/box/reified/varargs.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/reified/arraysReification") + @TestDataPath("$PROJECT_ROOT") + public class ArraysReification { + @Test + public void testAllFilesPresentInArraysReification() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/reified/arraysReification"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("jaggedArray.kt") + public void testJaggedArray() throws Exception { + runTest("compiler/testData/codegen/box/reified/arraysReification/jaggedArray.kt"); + } + + @Test + @TestMetadata("jaggedDeep.kt") + public void testJaggedDeep() throws Exception { + runTest("compiler/testData/codegen/box/reified/arraysReification/jaggedDeep.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/safeCall") + @TestDataPath("$PROJECT_ROOT") + public class SafeCall { + @Test + public void testAllFilesPresentInSafeCall() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/safeCall"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("genericNull.kt") + public void testGenericNull() throws Exception { + runTest("compiler/testData/codegen/box/safeCall/genericNull.kt"); + } + + @Test + @TestMetadata("kt1572.kt") + public void testKt1572() throws Exception { + runTest("compiler/testData/codegen/box/safeCall/kt1572.kt"); + } + + @Test + @TestMetadata("kt232.kt") + public void testKt232() throws Exception { + runTest("compiler/testData/codegen/box/safeCall/kt232.kt"); + } + + @Test + @TestMetadata("kt245.kt") + public void testKt245() throws Exception { + runTest("compiler/testData/codegen/box/safeCall/kt245.kt"); + } + + @Test + @TestMetadata("kt247.kt") + public void testKt247() throws Exception { + runTest("compiler/testData/codegen/box/safeCall/kt247.kt"); + } + + @Test + @TestMetadata("kt3430.kt") + public void testKt3430() throws Exception { + runTest("compiler/testData/codegen/box/safeCall/kt3430.kt"); + } + + @Test + @TestMetadata("kt4733.kt") + public void testKt4733() throws Exception { + runTest("compiler/testData/codegen/box/safeCall/kt4733.kt"); + } + + @Test + @TestMetadata("kt52580.kt") + public void testKt52580() throws Exception { + runTest("compiler/testData/codegen/box/safeCall/kt52580.kt"); + } + + @Test + @TestMetadata("kt52743.kt") + public void testKt52743() throws Exception { + runTest("compiler/testData/codegen/box/safeCall/kt52743.kt"); + } + + @Test + @TestMetadata("primitive.kt") + public void testPrimitive() throws Exception { + runTest("compiler/testData/codegen/box/safeCall/primitive.kt"); + } + + @Test + @TestMetadata("primitiveEqSafeCall.kt") + public void testPrimitiveEqSafeCall() throws Exception { + runTest("compiler/testData/codegen/box/safeCall/primitiveEqSafeCall.kt"); + } + + @Test + @TestMetadata("primitiveNotEqSafeCall.kt") + public void testPrimitiveNotEqSafeCall() throws Exception { + runTest("compiler/testData/codegen/box/safeCall/primitiveNotEqSafeCall.kt"); + } + + @Test + @TestMetadata("safeCallEqPrimitive.kt") + public void testSafeCallEqPrimitive() throws Exception { + runTest("compiler/testData/codegen/box/safeCall/safeCallEqPrimitive.kt"); + } + + @Test + @TestMetadata("safeCallIOnUninitializedNonNullValue.kt") + public void testSafeCallIOnUninitializedNonNullValue() throws Exception { + runTest("compiler/testData/codegen/box/safeCall/safeCallIOnUninitializedNonNullValue.kt"); + } + + @Test + @TestMetadata("safeCallNotEqPrimitive.kt") + public void testSafeCallNotEqPrimitive() throws Exception { + runTest("compiler/testData/codegen/box/safeCall/safeCallNotEqPrimitive.kt"); + } + + @Test + @TestMetadata("safeCallOnLong.kt") + public void testSafeCallOnLong() throws Exception { + runTest("compiler/testData/codegen/box/safeCall/safeCallOnLong.kt"); + } + + @Test + @TestMetadata("safeCallWithElvisFolding.kt") + public void testSafeCallWithElvisFolding() throws Exception { + runTest("compiler/testData/codegen/box/safeCall/safeCallWithElvisFolding.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/sam") + @TestDataPath("$PROJECT_ROOT") + public class Sam { + @Test + public void testAllFilesPresentInSam() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt51821.kt") + public void testKt51821() throws Exception { + runTest("compiler/testData/codegen/box/sam/kt51821.kt"); + } + + @Test + @TestMetadata("kt56188.kt") + public void testKt56188() throws Exception { + runTest("compiler/testData/codegen/box/sam/kt56188.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/sam/adapters") + @TestDataPath("$PROJECT_ROOT") + public class Adapters { + @Test + public void testAllFilesPresentInAdapters() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/adapters"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/sam/adapters/operators") + @TestDataPath("$PROJECT_ROOT") + public class Operators { + @Test + public void testAllFilesPresentInOperators() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/adapters/operators"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/sam/approximation") + @TestDataPath("$PROJECT_ROOT") + public class Approximation { + @Test + public void testAllFilesPresentInApproximation() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/approximation"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("approxToIntermediateType.kt") + public void testApproxToIntermediateType() throws Exception { + runTest("compiler/testData/codegen/box/sam/approximation/approxToIntermediateType.kt"); + } + + @Test + @TestMetadata("approxToSingleUpperBound.kt") + public void testApproxToSingleUpperBound() throws Exception { + runTest("compiler/testData/codegen/box/sam/approximation/approxToSingleUpperBound.kt"); + } + + @Test + @TestMetadata("impossibleToApproxToRepresentable.kt") + public void testImpossibleToApproxToRepresentable() throws Exception { + runTest("compiler/testData/codegen/box/sam/approximation/impossibleToApproxToRepresentable.kt"); + } + + @Test + @TestMetadata("impossibleToApproxToRepresentable2.kt") + public void testImpossibleToApproxToRepresentable2() throws Exception { + runTest("compiler/testData/codegen/box/sam/approximation/impossibleToApproxToRepresentable2.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/sam/constructors") + @TestDataPath("$PROJECT_ROOT") + public class Constructors { + @Test + public void testAllFilesPresentInConstructors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/constructors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("comparator.kt") + public void testComparator() throws Exception { + runTest("compiler/testData/codegen/box/sam/constructors/comparator.kt"); + } + + @Test + @TestMetadata("nonLiteralComparator.kt") + public void testNonLiteralComparator() throws Exception { + runTest("compiler/testData/codegen/box/sam/constructors/nonLiteralComparator.kt"); + } + + @Test + @TestMetadata("sameWrapperClass2.kt") + public void testSameWrapperClass2() throws Exception { + runTest("compiler/testData/codegen/box/sam/constructors/sameWrapperClass2.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/sam/equality") + @TestDataPath("$PROJECT_ROOT") + public class Equality { + @Test + public void testAllFilesPresentInEquality() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/equality"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/sam/javaSamWithEqualsHashCode") + @TestDataPath("$PROJECT_ROOT") + public class JavaSamWithEqualsHashCode { + @Test + public void testAllFilesPresentInJavaSamWithEqualsHashCode() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sam/javaSamWithEqualsHashCode"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/sameFileInSourceAndDependencies") + @TestDataPath("$PROJECT_ROOT") + public class SameFileInSourceAndDependencies { + @Test + public void testAllFilesPresentInSameFileInSourceAndDependencies() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sameFileInSourceAndDependencies"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("classDeclaration.kt") + public void testClassDeclaration() throws Exception { + runTest("compiler/testData/codegen/box/sameFileInSourceAndDependencies/classDeclaration.kt"); + } + + @Test + @TestMetadata("differingNumberOfGenericTypeParameters.kt") + public void testDifferingNumberOfGenericTypeParameters() throws Exception { + runTest("compiler/testData/codegen/box/sameFileInSourceAndDependencies/differingNumberOfGenericTypeParameters.kt"); + } + + @Test + @TestMetadata("functionDeclaration.kt") + public void testFunctionDeclaration() throws Exception { + runTest("compiler/testData/codegen/box/sameFileInSourceAndDependencies/functionDeclaration.kt"); + } + + @Test + @TestMetadata("lateinitMemberPropertyDeclaration.kt") + public void testLateinitMemberPropertyDeclaration() throws Exception { + runTest("compiler/testData/codegen/box/sameFileInSourceAndDependencies/lateinitMemberPropertyDeclaration.kt"); + } + + @Test + @TestMetadata("memberFunctionDeclaration.kt") + public void testMemberFunctionDeclaration() throws Exception { + runTest("compiler/testData/codegen/box/sameFileInSourceAndDependencies/memberFunctionDeclaration.kt"); + } + + @Test + @TestMetadata("memberFunctionWithDefaultArgumentsDeclaration.kt") + public void testMemberFunctionWithDefaultArgumentsDeclaration() throws Exception { + runTest("compiler/testData/codegen/box/sameFileInSourceAndDependencies/memberFunctionWithDefaultArgumentsDeclaration.kt"); + } + + @Test + @TestMetadata("memberPropertyDeclaration.kt") + public void testMemberPropertyDeclaration() throws Exception { + runTest("compiler/testData/codegen/box/sameFileInSourceAndDependencies/memberPropertyDeclaration.kt"); + } + + @Test + @TestMetadata("nestedClassDeclaration.kt") + public void testNestedClassDeclaration() throws Exception { + runTest("compiler/testData/codegen/box/sameFileInSourceAndDependencies/nestedClassDeclaration.kt"); + } + + @Test + @TestMetadata("propertyDeclaration.kt") + public void testPropertyDeclaration() throws Exception { + runTest("compiler/testData/codegen/box/sameFileInSourceAndDependencies/propertyDeclaration.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/script") + @TestDataPath("$PROJECT_ROOT") + public class Script { + @Test + public void testAllFilesPresentInScript() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/script"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/sealed") + @TestDataPath("$PROJECT_ROOT") + public class Sealed { + @Test + public void testAllFilesPresentInSealed() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/sealed"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("delegatingConstructor.kt") + public void testDelegatingConstructor() throws Exception { + runTest("compiler/testData/codegen/box/sealed/delegatingConstructor.kt"); + } + + @Test + @TestMetadata("kt49752.kt") + public void testKt49752() throws Exception { + runTest("compiler/testData/codegen/box/sealed/kt49752.kt"); + } + + @Test + @TestMetadata("kt54028.kt") + public void testKt54028() throws Exception { + runTest("compiler/testData/codegen/box/sealed/kt54028.kt"); + } + + @Test + @TestMetadata("kt54028_cursed.kt") + public void testKt54028_cursed() throws Exception { + runTest("compiler/testData/codegen/box/sealed/kt54028_cursed.kt"); + } + + @Test + @TestMetadata("multipleFiles_enabled.kt") + public void testMultipleFiles_enabled() throws Exception { + runTest("compiler/testData/codegen/box/sealed/multipleFiles_enabled.kt"); + } + + @Test + @TestMetadata("objects.kt") + public void testObjects() throws Exception { + runTest("compiler/testData/codegen/box/sealed/objects.kt"); + } + + @Test + @TestMetadata("sealedInSameFile.kt") + public void testSealedInSameFile() throws Exception { + runTest("compiler/testData/codegen/box/sealed/sealedInSameFile.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/sealed/simple.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/secondaryConstructors") + @TestDataPath("$PROJECT_ROOT") + public class SecondaryConstructors { + @Test + @TestMetadata("accessToCompanion.kt") + public void testAccessToCompanion() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/accessToCompanion.kt"); + } + + @Test + @TestMetadata("accessToNestedObject.kt") + public void testAccessToNestedObject() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/accessToNestedObject.kt"); + } + + @Test + public void testAllFilesPresentInSecondaryConstructors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/secondaryConstructors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("basicNoPrimaryManySinks.kt") + public void testBasicNoPrimaryManySinks() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/basicNoPrimaryManySinks.kt"); + } + + @Test + @TestMetadata("basicNoPrimaryOneSink.kt") + public void testBasicNoPrimaryOneSink() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/basicNoPrimaryOneSink.kt"); + } + + @Test + @TestMetadata("basicPrimary.kt") + public void testBasicPrimary() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/basicPrimary.kt"); + } + + @Test + @TestMetadata("callFromLocalSubClass.kt") + public void testCallFromLocalSubClass() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/callFromLocalSubClass.kt"); + } + + @Test + @TestMetadata("callFromPrimaryWithNamedArgs.kt") + public void testCallFromPrimaryWithNamedArgs() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/callFromPrimaryWithNamedArgs.kt"); + } + + @Test + @TestMetadata("callFromPrimaryWithOptionalArgs.kt") + public void testCallFromPrimaryWithOptionalArgs() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/callFromPrimaryWithOptionalArgs.kt"); + } + + @Test + @TestMetadata("callFromSubClass.kt") + public void testCallFromSubClass() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/callFromSubClass.kt"); + } + + @Test + @TestMetadata("clashingDefaultConstructors.kt") + public void testClashingDefaultConstructors() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/clashingDefaultConstructors.kt"); + } + + @Test + @TestMetadata("dataClasses.kt") + public void testDataClasses() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/dataClasses.kt"); + } + + @Test + @TestMetadata("defaultArgs.kt") + public void testDefaultArgs() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/defaultArgs.kt"); + } + + @Test + @TestMetadata("defaultParametersNotDuplicated.kt") + public void testDefaultParametersNotDuplicated() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/defaultParametersNotDuplicated.kt"); + } + + @Test + @TestMetadata("delegateWithComplexExpression.kt") + public void testDelegateWithComplexExpression() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/delegateWithComplexExpression.kt"); + } + + @Test + @TestMetadata("delegatedThisWithLambda.kt") + public void testDelegatedThisWithLambda() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/delegatedThisWithLambda.kt"); + } + + @Test + @TestMetadata("delegationWithPrimary.kt") + public void testDelegationWithPrimary() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/delegationWithPrimary.kt"); + } + + @Test + @TestMetadata("enums.kt") + public void testEnums() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/enums.kt"); + } + + @Test + @TestMetadata("fieldInitializerOptimization.kt") + public void testFieldInitializerOptimization() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/fieldInitializerOptimization.kt"); + } + + @Test + @TestMetadata("generics.kt") + public void testGenerics() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/generics.kt"); + } + + @Test + @TestMetadata("inlineIntoTwoConstructors.kt") + public void testInlineIntoTwoConstructors() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/inlineIntoTwoConstructors.kt"); + } + + @Test + @TestMetadata("innerClasses.kt") + public void testInnerClasses() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/innerClasses.kt"); + } + + @Test + @TestMetadata("innerClassesInheritance.kt") + public void testInnerClassesInheritance() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/innerClassesInheritance.kt"); + } + + @Test + @TestMetadata("localClasses.kt") + public void testLocalClasses() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/localClasses.kt"); + } + + @Test + @TestMetadata("superCallPrimary.kt") + public void testSuperCallPrimary() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/superCallPrimary.kt"); + } + + @Test + @TestMetadata("superCallSecondary.kt") + public void testSuperCallSecondary() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/superCallSecondary.kt"); + } + + @Test + @TestMetadata("varargs.kt") + public void testVarargs() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/varargs.kt"); + } + + @Test + @TestMetadata("withNonLocalReturn.kt") + public void testWithNonLocalReturn() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/withNonLocalReturn.kt"); + } + + @Test + @TestMetadata("withReturn.kt") + public void testWithReturn() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/withReturn.kt"); + } + + @Test + @TestMetadata("withReturnUnit.kt") + public void testWithReturnUnit() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/withReturnUnit.kt"); + } + + @Test + @TestMetadata("withoutPrimarySimple.kt") + public void testWithoutPrimarySimple() throws Exception { + runTest("compiler/testData/codegen/box/secondaryConstructors/withoutPrimarySimple.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/size") + @TestDataPath("$PROJECT_ROOT") + public class Size { + @Test + @TestMetadata("add.kt") + public void testAdd() throws Exception { + runTest("compiler/testData/codegen/box/size/add.kt"); + } + + @Test + public void testAllFilesPresentInSize() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/size"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("helloWorld.kt") + public void testHelloWorld() throws Exception { + runTest("compiler/testData/codegen/box/size/helloWorld.kt"); + } + + @Test + @TestMetadata("helloWorldDOM.kt") + public void testHelloWorldDOM() throws Exception { + runTest("compiler/testData/codegen/box/size/helloWorldDOM.kt"); + } + + @Test + @TestMetadata("objectsOptimization.kt") + public void testObjectsOptimization() throws Exception { + runTest("compiler/testData/codegen/box/size/objectsOptimization.kt"); + } + + @Test + @TestMetadata("ok.kt") + public void testOk() throws Exception { + runTest("compiler/testData/codegen/box/size/ok.kt"); + } + + @Test + @TestMetadata("removeUnusedOverride.kt") + public void testRemoveUnusedOverride() throws Exception { + runTest("compiler/testData/codegen/box/size/removeUnusedOverride.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/smap") + @TestDataPath("$PROJECT_ROOT") + public class Smap { + @Test + public void testAllFilesPresentInSmap() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smap"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/smartCasts") + @TestDataPath("$PROJECT_ROOT") + public class SmartCasts { + @Test + public void testAllFilesPresentInSmartCasts() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/smartCasts"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("avoidSmartCastToDerivedForPrivate.kt") + public void testAvoidSmartCastToDerivedForPrivate() throws Exception { + runTest("compiler/testData/codegen/box/smartCasts/avoidSmartCastToDerivedForPrivate.kt"); + } + + @Test + @TestMetadata("complexExplicitReceiver.kt") + public void testComplexExplicitReceiver() throws Exception { + runTest("compiler/testData/codegen/box/smartCasts/complexExplicitReceiver.kt"); + } + + @Test + @TestMetadata("complexImplicitReceiver.kt") + public void testComplexImplicitReceiver() throws Exception { + runTest("compiler/testData/codegen/box/smartCasts/complexImplicitReceiver.kt"); + } + + @Test + @TestMetadata("falseSmartCast.kt") + public void testFalseSmartCast() throws Exception { + runTest("compiler/testData/codegen/box/smartCasts/falseSmartCast.kt"); + } + + @Test + @TestMetadata("genericIntersection.kt") + public void testGenericIntersection() throws Exception { + runTest("compiler/testData/codegen/box/smartCasts/genericIntersection.kt"); + } + + @Test + @TestMetadata("genericSet.kt") + public void testGenericSet() throws Exception { + runTest("compiler/testData/codegen/box/smartCasts/genericSet.kt"); + } + + @Test + @TestMetadata("implicitExtensionReceiver.kt") + public void testImplicitExtensionReceiver() throws Exception { + runTest("compiler/testData/codegen/box/smartCasts/implicitExtensionReceiver.kt"); + } + + @Test + @TestMetadata("implicitMemberReceiver.kt") + public void testImplicitMemberReceiver() throws Exception { + runTest("compiler/testData/codegen/box/smartCasts/implicitMemberReceiver.kt"); + } + + @Test + @TestMetadata("implicitReceiver.kt") + public void testImplicitReceiver() throws Exception { + runTest("compiler/testData/codegen/box/smartCasts/implicitReceiver.kt"); + } + + @Test + @TestMetadata("implicitReceiverInWhen.kt") + public void testImplicitReceiverInWhen() throws Exception { + runTest("compiler/testData/codegen/box/smartCasts/implicitReceiverInWhen.kt"); + } + + @Test + @TestMetadata("implicitToGrandSon.kt") + public void testImplicitToGrandSon() throws Exception { + runTest("compiler/testData/codegen/box/smartCasts/implicitToGrandSon.kt"); + } + + @Test + @TestMetadata("kt17725.kt") + public void testKt17725() throws Exception { + runTest("compiler/testData/codegen/box/smartCasts/kt17725.kt"); + } + + @Test + @TestMetadata("kt19100.kt") + public void testKt19100() throws Exception { + runTest("compiler/testData/codegen/box/smartCasts/kt19100.kt"); + } + + @Test + @TestMetadata("kt42517.kt") + public void testKt42517() throws Exception { + runTest("compiler/testData/codegen/box/smartCasts/kt42517.kt"); + } + + @Test + @TestMetadata("kt44804.kt") + public void testKt44804() throws Exception { + runTest("compiler/testData/codegen/box/smartCasts/kt44804.kt"); + } + + @Test + @TestMetadata("kt44814.kt") + public void testKt44814() throws Exception { + runTest("compiler/testData/codegen/box/smartCasts/kt44814.kt"); + } + + @Test + @TestMetadata("kt44932.kt") + public void testKt44932() throws Exception { + runTest("compiler/testData/codegen/box/smartCasts/kt44932.kt"); + } + + @Test + @TestMetadata("kt44942.kt") + public void testKt44942() throws Exception { + runTest("compiler/testData/codegen/box/smartCasts/kt44942.kt"); + } + + @Test + @TestMetadata("kt52432.kt") + public void testKt52432() throws Exception { + runTest("compiler/testData/codegen/box/smartCasts/kt52432.kt"); + } + + @Test + @TestMetadata("lambdaArgumentWithoutType.kt") + public void testLambdaArgumentWithoutType() throws Exception { + runTest("compiler/testData/codegen/box/smartCasts/lambdaArgumentWithoutType.kt"); + } + + @Test + @TestMetadata("multipleSmartCast.kt") + public void testMultipleSmartCast() throws Exception { + runTest("compiler/testData/codegen/box/smartCasts/multipleSmartCast.kt"); + } + + @Test + @TestMetadata("nullSmartCast.kt") + public void testNullSmartCast() throws Exception { + runTest("compiler/testData/codegen/box/smartCasts/nullSmartCast.kt"); + } + + @Test + @TestMetadata("propertyInitializationAfterSmartCast.kt") + public void testPropertyInitializationAfterSmartCast() throws Exception { + runTest("compiler/testData/codegen/box/smartCasts/propertyInitializationAfterSmartCast.kt"); + } + + @Test + @TestMetadata("smartCastInsideIf.kt") + public void testSmartCastInsideIf() throws Exception { + runTest("compiler/testData/codegen/box/smartCasts/smartCastInsideIf.kt"); + } + + @Test + @TestMetadata("whenSmartCast.kt") + public void testWhenSmartCast() throws Exception { + runTest("compiler/testData/codegen/box/smartCasts/whenSmartCast.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/specialBuiltins") + @TestDataPath("$PROJECT_ROOT") + public class SpecialBuiltins { + @Test + public void testAllFilesPresentInSpecialBuiltins() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/specialBuiltins"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("bridgeNotEmptyMap.kt") + public void testBridgeNotEmptyMap() throws Exception { + runTest("compiler/testData/codegen/box/specialBuiltins/bridgeNotEmptyMap.kt"); + } + + @Test + @TestMetadata("bridges.kt") + public void testBridges() throws Exception { + runTest("compiler/testData/codegen/box/specialBuiltins/bridges.kt"); + } + + @Test + @TestMetadata("commonBridgesTarget.kt") + public void testCommonBridgesTarget() throws Exception { + runTest("compiler/testData/codegen/box/specialBuiltins/commonBridgesTarget.kt"); + } + + @Test + @TestMetadata("emptyList.kt") + public void testEmptyList() throws Exception { + runTest("compiler/testData/codegen/box/specialBuiltins/emptyList.kt"); + } + + @Test + @TestMetadata("emptyMap.kt") + public void testEmptyMap() throws Exception { + runTest("compiler/testData/codegen/box/specialBuiltins/emptyMap.kt"); + } + + @Test + @TestMetadata("emptyStringMap.kt") + public void testEmptyStringMap() throws Exception { + runTest("compiler/testData/codegen/box/specialBuiltins/emptyStringMap.kt"); + } + + @Test + @TestMetadata("entrySetSOE.kt") + public void testEntrySetSOE() throws Exception { + runTest("compiler/testData/codegen/box/specialBuiltins/entrySetSOE.kt"); + } + + @Test + @TestMetadata("enumAsOrdinaled.kt") + public void testEnumAsOrdinaled() throws Exception { + runTest("compiler/testData/codegen/box/specialBuiltins/enumAsOrdinaled.kt"); + } + + @Test + @TestMetadata("exceptionCause.kt") + public void testExceptionCause() throws Exception { + runTest("compiler/testData/codegen/box/specialBuiltins/exceptionCause.kt"); + } + + @Test + @TestMetadata("explicitSuperCall.kt") + public void testExplicitSuperCall() throws Exception { + runTest("compiler/testData/codegen/box/specialBuiltins/explicitSuperCall.kt"); + } + + @Test + @TestMetadata("irrelevantRemoveAtOverride.kt") + public void testIrrelevantRemoveAtOverride() throws Exception { + runTest("compiler/testData/codegen/box/specialBuiltins/irrelevantRemoveAtOverride.kt"); + } + + @Test + @TestMetadata("maps.kt") + public void testMaps() throws Exception { + runTest("compiler/testData/codegen/box/specialBuiltins/maps.kt"); + } + + @Test + @TestMetadata("noSpecialBridgeInSuperClass.kt") + public void testNoSpecialBridgeInSuperClass() throws Exception { + runTest("compiler/testData/codegen/box/specialBuiltins/noSpecialBridgeInSuperClass.kt"); + } + + @Test + @TestMetadata("notEmptyListAny.kt") + public void testNotEmptyListAny() throws Exception { + runTest("compiler/testData/codegen/box/specialBuiltins/notEmptyListAny.kt"); + } + + @Test + @TestMetadata("notEmptyMap.kt") + public void testNotEmptyMap() throws Exception { + runTest("compiler/testData/codegen/box/specialBuiltins/notEmptyMap.kt"); + } + + @Test + @TestMetadata("redundantStubForSize.kt") + public void testRedundantStubForSize() throws Exception { + runTest("compiler/testData/codegen/box/specialBuiltins/redundantStubForSize.kt"); + } + + @Test + @TestMetadata("removeAtTwoSpecialBridges.kt") + public void testRemoveAtTwoSpecialBridges() throws Exception { + runTest("compiler/testData/codegen/box/specialBuiltins/removeAtTwoSpecialBridges.kt"); + } + + @Test + @TestMetadata("removeSetInt.kt") + public void testRemoveSetInt() throws Exception { + runTest("compiler/testData/codegen/box/specialBuiltins/removeSetInt.kt"); + } + + @Test + @TestMetadata("throwable.kt") + public void testThrowable() throws Exception { + runTest("compiler/testData/codegen/box/specialBuiltins/throwable.kt"); + } + + @Test + @TestMetadata("throwableCause.kt") + public void testThrowableCause() throws Exception { + runTest("compiler/testData/codegen/box/specialBuiltins/throwableCause.kt"); + } + + @Test + @TestMetadata("throwableComplex.kt") + public void testThrowableComplex() throws Exception { + runTest("compiler/testData/codegen/box/specialBuiltins/throwableComplex.kt"); + } + + @Test + @TestMetadata("throwableImpl.kt") + public void testThrowableImpl() throws Exception { + runTest("compiler/testData/codegen/box/specialBuiltins/throwableImpl.kt"); + } + + @Test + @TestMetadata("throwableImplWithSecondaryConstructor.kt") + public void testThrowableImplWithSecondaryConstructor() throws Exception { + runTest("compiler/testData/codegen/box/specialBuiltins/throwableImplWithSecondaryConstructor.kt"); + } + + @Test + @TestMetadata("valuesInsideEnum.kt") + public void testValuesInsideEnum() throws Exception { + runTest("compiler/testData/codegen/box/specialBuiltins/valuesInsideEnum.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/statics") + @TestDataPath("$PROJECT_ROOT") + public class Statics { + @Test + public void testAllFilesPresentInStatics() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/statics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("anonymousInitializerIObject.kt") + public void testAnonymousInitializerIObject() throws Exception { + runTest("compiler/testData/codegen/box/statics/anonymousInitializerIObject.kt"); + } + + @Test + @TestMetadata("anonymousInitializerInClassObject.kt") + public void testAnonymousInitializerInClassObject() throws Exception { + runTest("compiler/testData/codegen/box/statics/anonymousInitializerInClassObject.kt"); + } + + @Test + @TestMetadata("incInClassObject.kt") + public void testIncInClassObject() throws Exception { + runTest("compiler/testData/codegen/box/statics/incInClassObject.kt"); + } + + @Test + @TestMetadata("incInObject.kt") + public void testIncInObject() throws Exception { + runTest("compiler/testData/codegen/box/statics/incInObject.kt"); + } + + @Test + @TestMetadata("inheritedPropertyInClassObject.kt") + public void testInheritedPropertyInClassObject() throws Exception { + runTest("compiler/testData/codegen/box/statics/inheritedPropertyInClassObject.kt"); + } + + @Test + @TestMetadata("inheritedPropertyInObject.kt") + public void testInheritedPropertyInObject() throws Exception { + runTest("compiler/testData/codegen/box/statics/inheritedPropertyInObject.kt"); + } + + @Test + @TestMetadata("kt8089.kt") + public void testKt8089() throws Exception { + runTest("compiler/testData/codegen/box/statics/kt8089.kt"); + } + + @Test + @TestMetadata("syntheticAccessor.kt") + public void testSyntheticAccessor() throws Exception { + runTest("compiler/testData/codegen/box/statics/syntheticAccessor.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/storeStackBeforeInline") + @TestDataPath("$PROJECT_ROOT") + public class StoreStackBeforeInline { + @Test + public void testAllFilesPresentInStoreStackBeforeInline() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/storeStackBeforeInline"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("differentTypes.kt") + public void testDifferentTypes() throws Exception { + runTest("compiler/testData/codegen/box/storeStackBeforeInline/differentTypes.kt"); + } + + @Test + @TestMetadata("primitiveMerge.kt") + public void testPrimitiveMerge() throws Exception { + runTest("compiler/testData/codegen/box/storeStackBeforeInline/primitiveMerge.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/storeStackBeforeInline/simple.kt"); + } + + @Test + @TestMetadata("unreachableMarker.kt") + public void testUnreachableMarker() throws Exception { + runTest("compiler/testData/codegen/box/storeStackBeforeInline/unreachableMarker.kt"); + } + + @Test + @TestMetadata("withLambda.kt") + public void testWithLambda() throws Exception { + runTest("compiler/testData/codegen/box/storeStackBeforeInline/withLambda.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/strings") + @TestDataPath("$PROJECT_ROOT") + public class Strings { + @Test + public void testAllFilesPresentInStrings() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/strings"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("concatDynamicWithConstants.kt") + public void testConcatDynamicWithConstants() throws Exception { + runTest("compiler/testData/codegen/box/strings/concatDynamicWithConstants.kt"); + } + + @Test + @TestMetadata("concatDynamicWithSpecialSymbols.kt") + public void testConcatDynamicWithSpecialSymbols() throws Exception { + runTest("compiler/testData/codegen/box/strings/concatDynamicWithSpecialSymbols.kt"); + } + + @Test + @TestMetadata("concatGenericWithNullablePrimitiveUpperBound.kt") + public void testConcatGenericWithNullablePrimitiveUpperBound() throws Exception { + runTest("compiler/testData/codegen/box/strings/concatGenericWithNullablePrimitiveUpperBound.kt"); + } + + @Test + @TestMetadata("concatGenericWithPrimitiveUpperBound.kt") + public void testConcatGenericWithPrimitiveUpperBound() throws Exception { + runTest("compiler/testData/codegen/box/strings/concatGenericWithPrimitiveUpperBound.kt"); + } + + @Test + @TestMetadata("concatGenericWithStringUpperBound.kt") + public void testConcatGenericWithStringUpperBound() throws Exception { + runTest("compiler/testData/codegen/box/strings/concatGenericWithStringUpperBound.kt"); + } + + @Test + @TestMetadata("concatNullableGenericWithPrimitiveUpperBound.kt") + public void testConcatNullableGenericWithPrimitiveUpperBound() throws Exception { + runTest("compiler/testData/codegen/box/strings/concatNullableGenericWithPrimitiveUpperBound.kt"); + } + + @Test + @TestMetadata("constInStringTemplate.kt") + public void testConstInStringTemplate() throws Exception { + runTest("compiler/testData/codegen/box/strings/constInStringTemplate.kt"); + } + + @Test + @TestMetadata("ea35743.kt") + public void testEa35743() throws Exception { + runTest("compiler/testData/codegen/box/strings/ea35743.kt"); + } + + @Test + @TestMetadata("forInString.kt") + public void testForInString() throws Exception { + runTest("compiler/testData/codegen/box/strings/forInString.kt"); + } + + @Test + @TestMetadata("interpolation.kt") + public void testInterpolation() throws Exception { + runTest("compiler/testData/codegen/box/strings/interpolation.kt"); + } + + @Test + @TestMetadata("kt13213.kt") + public void testKt13213() throws Exception { + runTest("compiler/testData/codegen/box/strings/kt13213.kt"); + } + + @Test + @TestMetadata("kt13213a.kt") + public void testKt13213a() throws Exception { + runTest("compiler/testData/codegen/box/strings/kt13213a.kt"); + } + + @Test + @TestMetadata("kt2592.kt") + public void testKt2592() throws Exception { + runTest("compiler/testData/codegen/box/strings/kt2592.kt"); + } + + @Test + @TestMetadata("kt3571.kt") + public void testKt3571() throws Exception { + runTest("compiler/testData/codegen/box/strings/kt3571.kt"); + } + + @Test + @TestMetadata("kt3652.kt") + public void testKt3652() throws Exception { + runTest("compiler/testData/codegen/box/strings/kt3652.kt"); + } + + @Test + @TestMetadata("kt47917.kt") + public void testKt47917() throws Exception { + runTest("compiler/testData/codegen/box/strings/kt47917.kt"); + } + + @Test + @TestMetadata("kt50140.kt") + public void testKt50140() throws Exception { + runTest("compiler/testData/codegen/box/strings/kt50140.kt"); + } + + @Test + @TestMetadata("kt5389_stringBuilderGet.kt") + public void testKt5389_stringBuilderGet() throws Exception { + runTest("compiler/testData/codegen/box/strings/kt5389_stringBuilderGet.kt"); + } + + @Test + @TestMetadata("kt5956.kt") + public void testKt5956() throws Exception { + runTest("compiler/testData/codegen/box/strings/kt5956.kt"); + } + + @Test + @TestMetadata("kt881.kt") + public void testKt881() throws Exception { + runTest("compiler/testData/codegen/box/strings/kt881.kt"); + } + + @Test + @TestMetadata("kt889.kt") + public void testKt889() throws Exception { + runTest("compiler/testData/codegen/box/strings/kt889.kt"); + } + + @Test + @TestMetadata("kt894.kt") + public void testKt894() throws Exception { + runTest("compiler/testData/codegen/box/strings/kt894.kt"); + } + + @Test + @TestMetadata("multilineStringsWithTemplates.kt") + public void testMultilineStringsWithTemplates() throws Exception { + runTest("compiler/testData/codegen/box/strings/multilineStringsWithTemplates.kt"); + } + + @Test + @TestMetadata("nestedConcat.kt") + public void testNestedConcat() throws Exception { + runTest("compiler/testData/codegen/box/strings/nestedConcat.kt"); + } + + @Test + @TestMetadata("rawStrings.kt") + public void testRawStrings() throws Exception { + runTest("compiler/testData/codegen/box/strings/rawStrings.kt"); + } + + @Test + @TestMetadata("rawStringsWithManyQuotes.kt") + public void testRawStringsWithManyQuotes() throws Exception { + runTest("compiler/testData/codegen/box/strings/rawStringsWithManyQuotes.kt"); + } + + @Test + @TestMetadata("simpleStringPlus.kt") + public void testSimpleStringPlus() throws Exception { + runTest("compiler/testData/codegen/box/strings/simpleStringPlus.kt"); + } + + @Test + @TestMetadata("singleConcatNullable.kt") + public void testSingleConcatNullable() throws Exception { + runTest("compiler/testData/codegen/box/strings/singleConcatNullable.kt"); + } + + @Test + @TestMetadata("stringBuilderAppend.kt") + public void testStringBuilderAppend() throws Exception { + runTest("compiler/testData/codegen/box/strings/stringBuilderAppend.kt"); + } + + @Test + @TestMetadata("stringPlusOnlyWorksOnString.kt") + public void testStringPlusOnlyWorksOnString() throws Exception { + runTest("compiler/testData/codegen/box/strings/stringPlusOnlyWorksOnString.kt"); + } + + @Test + @TestMetadata("stringPlusOverride.kt") + public void testStringPlusOverride() throws Exception { + runTest("compiler/testData/codegen/box/strings/stringPlusOverride.kt"); + } + + @Test + @TestMetadata("surrogatePair.kt") + public void testSurrogatePair() throws Exception { + runTest("compiler/testData/codegen/box/strings/surrogatePair.kt"); + } + + @Test + @TestMetadata("trimOptimization.kt") + public void testTrimOptimization() throws Exception { + runTest("compiler/testData/codegen/box/strings/trimOptimization.kt"); + } + + @Test + @TestMetadata("twoArgumentNullableStringOperatorPlus.kt") + public void testTwoArgumentNullableStringOperatorPlus() throws Exception { + runTest("compiler/testData/codegen/box/strings/twoArgumentNullableStringOperatorPlus.kt"); + } + + @Test + @TestMetadata("twoArgumentNullableStringPlus.kt") + public void testTwoArgumentNullableStringPlus() throws Exception { + runTest("compiler/testData/codegen/box/strings/twoArgumentNullableStringPlus.kt"); + } + + @Test + @TestMetadata("twoArgumentStringTemplate.kt") + public void testTwoArgumentStringTemplate() throws Exception { + runTest("compiler/testData/codegen/box/strings/twoArgumentStringTemplate.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/super") + @TestDataPath("$PROJECT_ROOT") + public class Super { + @Test + public void testAllFilesPresentInSuper() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("basicmethodSuperClass.kt") + public void testBasicmethodSuperClass() throws Exception { + runTest("compiler/testData/codegen/box/super/basicmethodSuperClass.kt"); + } + + @Test + @TestMetadata("basicmethodSuperTrait.kt") + public void testBasicmethodSuperTrait() throws Exception { + runTest("compiler/testData/codegen/box/super/basicmethodSuperTrait.kt"); + } + + @Test + @TestMetadata("basicproperty.kt") + public void testBasicproperty() throws Exception { + runTest("compiler/testData/codegen/box/super/basicproperty.kt"); + } + + @Test + @TestMetadata("enclosedFun.kt") + public void testEnclosedFun() throws Exception { + runTest("compiler/testData/codegen/box/super/enclosedFun.kt"); + } + + @Test + @TestMetadata("enclosedVar.kt") + public void testEnclosedVar() throws Exception { + runTest("compiler/testData/codegen/box/super/enclosedVar.kt"); + } + + @Test + @TestMetadata("innerClassLabeledSuper.kt") + public void testInnerClassLabeledSuper() throws Exception { + runTest("compiler/testData/codegen/box/super/innerClassLabeledSuper.kt"); + } + + @Test + @TestMetadata("innerClassLabeledSuper2.kt") + public void testInnerClassLabeledSuper2() throws Exception { + runTest("compiler/testData/codegen/box/super/innerClassLabeledSuper2.kt"); + } + + @Test + @TestMetadata("innerClassLabeledSuperProperty.kt") + public void testInnerClassLabeledSuperProperty() throws Exception { + runTest("compiler/testData/codegen/box/super/innerClassLabeledSuperProperty.kt"); + } + + @Test + @TestMetadata("innerClassLabeledSuperProperty2.kt") + public void testInnerClassLabeledSuperProperty2() throws Exception { + runTest("compiler/testData/codegen/box/super/innerClassLabeledSuperProperty2.kt"); + } + + @Test + @TestMetadata("innerClassQualifiedFunctionCall.kt") + public void testInnerClassQualifiedFunctionCall() throws Exception { + runTest("compiler/testData/codegen/box/super/innerClassQualifiedFunctionCall.kt"); + } + + @Test + @TestMetadata("innerClassQualifiedPropertyAccess.kt") + public void testInnerClassQualifiedPropertyAccess() throws Exception { + runTest("compiler/testData/codegen/box/super/innerClassQualifiedPropertyAccess.kt"); + } + + @Test + @TestMetadata("interfaceHashCode.kt") + public void testInterfaceHashCode() throws Exception { + runTest("compiler/testData/codegen/box/super/interfaceHashCode.kt"); + } + + @Test + @TestMetadata("kt14243.kt") + public void testKt14243() throws Exception { + runTest("compiler/testData/codegen/box/super/kt14243.kt"); + } + + @Test + @TestMetadata("kt14243_2.kt") + public void testKt14243_2() throws Exception { + runTest("compiler/testData/codegen/box/super/kt14243_2.kt"); + } + + @Test + @TestMetadata("kt14243_class.kt") + public void testKt14243_class() throws Exception { + runTest("compiler/testData/codegen/box/super/kt14243_class.kt"); + } + + @Test + @TestMetadata("kt14243_prop.kt") + public void testKt14243_prop() throws Exception { + runTest("compiler/testData/codegen/box/super/kt14243_prop.kt"); + } + + @Test + @TestMetadata("kt3492ClassFun.kt") + public void testKt3492ClassFun() throws Exception { + runTest("compiler/testData/codegen/box/super/kt3492ClassFun.kt"); + } + + @Test + @TestMetadata("kt3492ClassProperty.kt") + public void testKt3492ClassProperty() throws Exception { + runTest("compiler/testData/codegen/box/super/kt3492ClassProperty.kt"); + } + + @Test + @TestMetadata("kt3492TraitFun.kt") + public void testKt3492TraitFun() throws Exception { + runTest("compiler/testData/codegen/box/super/kt3492TraitFun.kt"); + } + + @Test + @TestMetadata("kt3492TraitProperty.kt") + public void testKt3492TraitProperty() throws Exception { + runTest("compiler/testData/codegen/box/super/kt3492TraitProperty.kt"); + } + + @Test + @TestMetadata("kt4173.kt") + public void testKt4173() throws Exception { + runTest("compiler/testData/codegen/box/super/kt4173.kt"); + } + + @Test + @TestMetadata("kt4173_2.kt") + public void testKt4173_2() throws Exception { + runTest("compiler/testData/codegen/box/super/kt4173_2.kt"); + } + + @Test + @TestMetadata("kt4173_3.kt") + public void testKt4173_3() throws Exception { + runTest("compiler/testData/codegen/box/super/kt4173_3.kt"); + } + + @Test + @TestMetadata("kt4982.kt") + public void testKt4982() throws Exception { + runTest("compiler/testData/codegen/box/super/kt4982.kt"); + } + + @Test + @TestMetadata("multipleSuperTraits.kt") + public void testMultipleSuperTraits() throws Exception { + runTest("compiler/testData/codegen/box/super/multipleSuperTraits.kt"); + } + + @Test + @TestMetadata("superCallToNonGenericImplThroughGenericDefaultImpls.kt") + public void testSuperCallToNonGenericImplThroughGenericDefaultImpls() throws Exception { + runTest("compiler/testData/codegen/box/super/superCallToNonGenericImplThroughGenericDefaultImpls.kt"); + } + + @Test + @TestMetadata("traitproperty.kt") + public void testTraitproperty() throws Exception { + runTest("compiler/testData/codegen/box/super/traitproperty.kt"); + } + + @Test + @TestMetadata("unqualifiedSuper.kt") + public void testUnqualifiedSuper() throws Exception { + runTest("compiler/testData/codegen/box/super/unqualifiedSuper.kt"); + } + + @Test + @TestMetadata("unqualifiedSuperWithDeeperHierarchies.kt") + public void testUnqualifiedSuperWithDeeperHierarchies() throws Exception { + runTest("compiler/testData/codegen/box/super/unqualifiedSuperWithDeeperHierarchies.kt"); + } + + @Test + @TestMetadata("unqualifiedSuperWithMethodsOfAny.kt") + public void testUnqualifiedSuperWithMethodsOfAny() throws Exception { + runTest("compiler/testData/codegen/box/super/unqualifiedSuperWithMethodsOfAny.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/super/superConstructor") + @TestDataPath("$PROJECT_ROOT") + public class SuperConstructor { + @Test + public void testAllFilesPresentInSuperConstructor() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/super/superConstructor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt13846.kt") + public void testKt13846() throws Exception { + runTest("compiler/testData/codegen/box/super/superConstructor/kt13846.kt"); + } + + @Test + @TestMetadata("kt17464_arrayOf.kt") + public void testKt17464_arrayOf() throws Exception { + runTest("compiler/testData/codegen/box/super/superConstructor/kt17464_arrayOf.kt"); + } + + @Test + @TestMetadata("kt17464_linkedMapOf.kt") + public void testKt17464_linkedMapOf() throws Exception { + runTest("compiler/testData/codegen/box/super/superConstructor/kt17464_linkedMapOf.kt"); + } + + @Test + @TestMetadata("kt18356.kt") + public void testKt18356() throws Exception { + runTest("compiler/testData/codegen/box/super/superConstructor/kt18356.kt"); + } + + @Test + @TestMetadata("kt18356_2.kt") + public void testKt18356_2() throws Exception { + runTest("compiler/testData/codegen/box/super/superConstructor/kt18356_2.kt"); + } + + @Test + @TestMetadata("objectExtendsInner.kt") + public void testObjectExtendsInner() throws Exception { + runTest("compiler/testData/codegen/box/super/superConstructor/objectExtendsInner.kt"); + } + + @Test + @TestMetadata("objectExtendsLocalInner.kt") + public void testObjectExtendsLocalInner() throws Exception { + runTest("compiler/testData/codegen/box/super/superConstructor/objectExtendsLocalInner.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/suppressions") + @TestDataPath("$PROJECT_ROOT") + public class Suppressions { + @Test + public void testAllFilesPresentInSuppressions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/suppressions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("suppressInvisible.kt") + public void testSuppressInvisible() throws Exception { + runTest("compiler/testData/codegen/box/suppressions/suppressInvisible.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/suspendConversion") + @TestDataPath("$PROJECT_ROOT") + public class SuspendConversion { + @Test + public void testAllFilesPresentInSuspendConversion() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/suspendConversion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("basicSuspendConversion.kt") + public void testBasicSuspendConversion() throws Exception { + runTest("compiler/testData/codegen/box/suspendConversion/basicSuspendConversion.kt"); + } + + @Test + @TestMetadata("basicSuspendConversionDefault.kt") + public void testBasicSuspendConversionDefault() throws Exception { + runTest("compiler/testData/codegen/box/suspendConversion/basicSuspendConversionDefault.kt"); + } + + @Test + @TestMetadata("basicSuspendConversionForCallableReference.kt") + public void testBasicSuspendConversionForCallableReference() throws Exception { + runTest("compiler/testData/codegen/box/suspendConversion/basicSuspendConversionForCallableReference.kt"); + } + + @Test + @TestMetadata("chainedFunSuspendConversionForSimpleExpression.kt") + public void testChainedFunSuspendConversionForSimpleExpression() throws Exception { + runTest("compiler/testData/codegen/box/suspendConversion/chainedFunSuspendConversionForSimpleExpression.kt"); + } + + @Test + @TestMetadata("kt50949_suspendConversionForExtensionFunction.kt") + public void testKt50949_suspendConversionForExtensionFunction() throws Exception { + runTest("compiler/testData/codegen/box/suspendConversion/kt50949_suspendConversionForExtensionFunction.kt"); + } + + @Test + @TestMetadata("overloadResolutionBySuspendModifier.kt") + public void testOverloadResolutionBySuspendModifier() throws Exception { + runTest("compiler/testData/codegen/box/suspendConversion/overloadResolutionBySuspendModifier.kt"); + } + + @Test + @TestMetadata("severalConversionsInOneCall.kt") + public void testSeveralConversionsInOneCall() throws Exception { + runTest("compiler/testData/codegen/box/suspendConversion/severalConversionsInOneCall.kt"); + } + + @Test + @TestMetadata("suspendAndFunConversionInDisabledMode.kt") + public void testSuspendAndFunConversionInDisabledMode() throws Exception { + runTest("compiler/testData/codegen/box/suspendConversion/suspendAndFunConversionInDisabledMode.kt"); + } + + @Test + @TestMetadata("suspendConversionCompatibility.kt") + public void testSuspendConversionCompatibility() throws Exception { + runTest("compiler/testData/codegen/box/suspendConversion/suspendConversionCompatibility.kt"); + } + + @Test + @TestMetadata("suspendConversionOnVarargElements.kt") + public void testSuspendConversionOnVarargElements() throws Exception { + runTest("compiler/testData/codegen/box/suspendConversion/suspendConversionOnVarargElements.kt"); + } + + @Test + @TestMetadata("suspendConversionWithFunInterfaces.kt") + public void testSuspendConversionWithFunInterfaces() throws Exception { + runTest("compiler/testData/codegen/box/suspendConversion/suspendConversionWithFunInterfaces.kt"); + } + + @Test + @TestMetadata("suspendConversionWithReferenceAdaptation.kt") + public void testSuspendConversionWithReferenceAdaptation() throws Exception { + runTest("compiler/testData/codegen/box/suspendConversion/suspendConversionWithReferenceAdaptation.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/synchronized") + @TestDataPath("$PROJECT_ROOT") + public class Synchronized { + @Test + public void testAllFilesPresentInSynchronized() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/synchronized"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/syntheticAccessors") + @TestDataPath("$PROJECT_ROOT") + public class SyntheticAccessors { + @Test + @TestMetadata("accessorForAbstractProtected.kt") + public void testAccessorForAbstractProtected() throws Exception { + runTest("compiler/testData/codegen/box/syntheticAccessors/accessorForAbstractProtected.kt"); + } + + @Test + @TestMetadata("accessorForGenericConstructor.kt") + public void testAccessorForGenericConstructor() throws Exception { + runTest("compiler/testData/codegen/box/syntheticAccessors/accessorForGenericConstructor.kt"); + } + + @Test + @TestMetadata("accessorForGenericMethod.kt") + public void testAccessorForGenericMethod() throws Exception { + runTest("compiler/testData/codegen/box/syntheticAccessors/accessorForGenericMethod.kt"); + } + + @Test + @TestMetadata("accessorForGenericMethodWithDefaults.kt") + public void testAccessorForGenericMethodWithDefaults() throws Exception { + runTest("compiler/testData/codegen/box/syntheticAccessors/accessorForGenericMethodWithDefaults.kt"); + } + + @Test + @TestMetadata("accessorForProtected.kt") + public void testAccessorForProtected() throws Exception { + runTest("compiler/testData/codegen/box/syntheticAccessors/accessorForProtected.kt"); + } + + @Test + @TestMetadata("accessorForProtectedInvokeVirtual.kt") + public void testAccessorForProtectedInvokeVirtual() throws Exception { + runTest("compiler/testData/codegen/box/syntheticAccessors/accessorForProtectedInvokeVirtual.kt"); + } + + @Test + @TestMetadata("accessorForProtectedPropertyReference.kt") + public void testAccessorForProtectedPropertyReference() throws Exception { + runTest("compiler/testData/codegen/box/syntheticAccessors/accessorForProtectedPropertyReference.kt"); + } + + @Test + public void testAllFilesPresentInSyntheticAccessors() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/syntheticAccessors"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("inline.kt") + public void testInline() throws Exception { + runTest("compiler/testData/codegen/box/syntheticAccessors/inline.kt"); + } + + @Test + @TestMetadata("inlineInOtherClass.kt") + public void testInlineInOtherClass() throws Exception { + runTest("compiler/testData/codegen/box/syntheticAccessors/inlineInOtherClass.kt"); + } + + @Test + @TestMetadata("kt10047.kt") + public void testKt10047() throws Exception { + runTest("compiler/testData/codegen/box/syntheticAccessors/kt10047.kt"); + } + + @Test + @TestMetadata("kt21258_indirect.kt") + public void testKt21258_indirect() throws Exception { + runTest("compiler/testData/codegen/box/syntheticAccessors/kt21258_indirect.kt"); + } + + @Test + @TestMetadata("kt21258_simple.kt") + public void testKt21258_simple() throws Exception { + runTest("compiler/testData/codegen/box/syntheticAccessors/kt21258_simple.kt"); + } + + @Test + @TestMetadata("kt49316.kt") + public void testKt49316() throws Exception { + runTest("compiler/testData/codegen/box/syntheticAccessors/kt49316.kt"); + } + + @Test + @TestMetadata("kt9717.kt") + public void testKt9717() throws Exception { + runTest("compiler/testData/codegen/box/syntheticAccessors/kt9717.kt"); + } + + @Test + @TestMetadata("kt9717DifferentPackages.kt") + public void testKt9717DifferentPackages() throws Exception { + runTest("compiler/testData/codegen/box/syntheticAccessors/kt9717DifferentPackages.kt"); + } + + @Test + @TestMetadata("kt9958.kt") + public void testKt9958() throws Exception { + runTest("compiler/testData/codegen/box/syntheticAccessors/kt9958.kt"); + } + + @Test + @TestMetadata("kt9958Interface.kt") + public void testKt9958Interface() throws Exception { + runTest("compiler/testData/codegen/box/syntheticAccessors/kt9958Interface.kt"); + } + + @Test + @TestMetadata("protectedFromLambda.kt") + public void testProtectedFromLambda() throws Exception { + runTest("compiler/testData/codegen/box/syntheticAccessors/protectedFromLambda.kt"); + } + + @Test + @TestMetadata("superCallFromMultipleSubclasses.kt") + public void testSuperCallFromMultipleSubclasses() throws Exception { + runTest("compiler/testData/codegen/box/syntheticAccessors/superCallFromMultipleSubclasses.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/syntheticAccessors/protectedJavaFieldAccessor") + @TestDataPath("$PROJECT_ROOT") + public class ProtectedJavaFieldAccessor { + @Test + public void testAllFilesPresentInProtectedJavaFieldAccessor() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/syntheticAccessors/protectedJavaFieldAccessor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/syntheticAccessors/protectedMemberReferenceAccessor") + @TestDataPath("$PROJECT_ROOT") + public class ProtectedMemberReferenceAccessor { + @Test + public void testAllFilesPresentInProtectedMemberReferenceAccessor() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/syntheticAccessors/protectedMemberReferenceAccessor"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt46597_crossinline_method.kt") + public void testKt46597_crossinline_method() throws Exception { + runTest("compiler/testData/codegen/box/syntheticAccessors/protectedMemberReferenceAccessor/kt46597_crossinline_method.kt"); + } + + @Test + @TestMetadata("kt46597_crossinline_property.kt") + public void testKt46597_crossinline_property() throws Exception { + runTest("compiler/testData/codegen/box/syntheticAccessors/protectedMemberReferenceAccessor/kt46597_crossinline_property.kt"); + } + + @Test + @TestMetadata("kt46597_method.kt") + public void testKt46597_method() throws Exception { + runTest("compiler/testData/codegen/box/syntheticAccessors/protectedMemberReferenceAccessor/kt46597_method.kt"); + } + + @Test + @TestMetadata("kt46597_property.kt") + public void testKt46597_property() throws Exception { + runTest("compiler/testData/codegen/box/syntheticAccessors/protectedMemberReferenceAccessor/kt46597_property.kt"); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/syntheticExtensions") + @TestDataPath("$PROJECT_ROOT") + public class SyntheticExtensions { + @Test + public void testAllFilesPresentInSyntheticExtensions() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/syntheticExtensions"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/throws") + @TestDataPath("$PROJECT_ROOT") + public class Throws { + @Test + public void testAllFilesPresentInThrows() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/throws"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/toArray") + @TestDataPath("$PROJECT_ROOT") + public class ToArray { + @Test + public void testAllFilesPresentInToArray() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/toArray"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt3177-toTypedArray.kt") + public void testKt3177_toTypedArray() throws Exception { + runTest("compiler/testData/codegen/box/toArray/kt3177-toTypedArray.kt"); + } + + @Test + @TestMetadata("returnToTypedArray.kt") + public void testReturnToTypedArray() throws Exception { + runTest("compiler/testData/codegen/box/toArray/returnToTypedArray.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/topLevelInitializtion") + @TestDataPath("$PROJECT_ROOT") + public class TopLevelInitializtion { + @Test + public void testAllFilesPresentInTopLevelInitializtion() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/topLevelInitializtion"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("failInInitializer1.kt") + public void testFailInInitializer1() throws Exception { + runTest("compiler/testData/codegen/box/topLevelInitializtion/failInInitializer1.kt"); + } + + @Test + @TestMetadata("failInInitializer2.kt") + public void testFailInInitializer2() throws Exception { + runTest("compiler/testData/codegen/box/topLevelInitializtion/failInInitializer2.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/topLevelPrivate") + @TestDataPath("$PROJECT_ROOT") + public class TopLevelPrivate { + @Test + public void testAllFilesPresentInTopLevelPrivate() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/topLevelPrivate"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("privateInInlineNested.kt") + public void testPrivateInInlineNested() throws Exception { + runTest("compiler/testData/codegen/box/topLevelPrivate/privateInInlineNested.kt"); + } + + @Test + @TestMetadata("syntheticAccessor.kt") + public void testSyntheticAccessor() throws Exception { + runTest("compiler/testData/codegen/box/topLevelPrivate/syntheticAccessor.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/trailingComma") + @TestDataPath("$PROJECT_ROOT") + public class TrailingComma { + @Test + public void testAllFilesPresentInTrailingComma() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/trailingComma"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("noDisambiguation.kt") + public void testNoDisambiguation() throws Exception { + runTest("compiler/testData/codegen/box/trailingComma/noDisambiguation.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/traits") + @TestDataPath("$PROJECT_ROOT") + public class Traits { + @Test + @TestMetadata("abstractClassWithFakeOverride.kt") + public void testAbstractClassWithFakeOverride() throws Exception { + runTest("compiler/testData/codegen/box/traits/abstractClassWithFakeOverride.kt"); + } + + @Test + public void testAllFilesPresentInTraits() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/traits"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("diamondPropertyAccessors.kt") + public void testDiamondPropertyAccessors() throws Exception { + runTest("compiler/testData/codegen/box/traits/diamondPropertyAccessors.kt"); + } + + @Test + @TestMetadata("doubleDiamond.kt") + public void testDoubleDiamond() throws Exception { + runTest("compiler/testData/codegen/box/traits/doubleDiamond.kt"); + } + + @Test + @TestMetadata("doubleGenericDiamond.kt") + public void testDoubleGenericDiamond() throws Exception { + runTest("compiler/testData/codegen/box/traits/doubleGenericDiamond.kt"); + } + + @Test + @TestMetadata("genericMethod.kt") + public void testGenericMethod() throws Exception { + runTest("compiler/testData/codegen/box/traits/genericMethod.kt"); + } + + @Test + @TestMetadata("indirectlyInheritPropertyGetter.kt") + public void testIndirectlyInheritPropertyGetter() throws Exception { + runTest("compiler/testData/codegen/box/traits/indirectlyInheritPropertyGetter.kt"); + } + + @Test + @TestMetadata("inheritedFun.kt") + public void testInheritedFun() throws Exception { + runTest("compiler/testData/codegen/box/traits/inheritedFun.kt"); + } + + @Test + @TestMetadata("inheritedVar.kt") + public void testInheritedVar() throws Exception { + runTest("compiler/testData/codegen/box/traits/inheritedVar.kt"); + } + + @Test + @TestMetadata("interfaceWithNonAbstractFunIndirect.kt") + public void testInterfaceWithNonAbstractFunIndirect() throws Exception { + runTest("compiler/testData/codegen/box/traits/interfaceWithNonAbstractFunIndirect.kt"); + } + + @Test + @TestMetadata("interfaceWithNonAbstractFunIndirectGeneric.kt") + public void testInterfaceWithNonAbstractFunIndirectGeneric() throws Exception { + runTest("compiler/testData/codegen/box/traits/interfaceWithNonAbstractFunIndirectGeneric.kt"); + } + + @Test + @TestMetadata("kt1936.kt") + public void testKt1936() throws Exception { + runTest("compiler/testData/codegen/box/traits/kt1936.kt"); + } + + @Test + @TestMetadata("kt1936_1.kt") + public void testKt1936_1() throws Exception { + runTest("compiler/testData/codegen/box/traits/kt1936_1.kt"); + } + + @Test + @TestMetadata("kt2260.kt") + public void testKt2260() throws Exception { + runTest("compiler/testData/codegen/box/traits/kt2260.kt"); + } + + @Test + @TestMetadata("kt2399.kt") + public void testKt2399() throws Exception { + runTest("compiler/testData/codegen/box/traits/kt2399.kt"); + } + + @Test + @TestMetadata("kt2541.kt") + public void testKt2541() throws Exception { + runTest("compiler/testData/codegen/box/traits/kt2541.kt"); + } + + @Test + @TestMetadata("kt3315.kt") + public void testKt3315() throws Exception { + runTest("compiler/testData/codegen/box/traits/kt3315.kt"); + } + + @Test + @TestMetadata("kt3500.kt") + public void testKt3500() throws Exception { + runTest("compiler/testData/codegen/box/traits/kt3500.kt"); + } + + @Test + @TestMetadata("kt3579.kt") + public void testKt3579() throws Exception { + runTest("compiler/testData/codegen/box/traits/kt3579.kt"); + } + + @Test + @TestMetadata("kt3579_2.kt") + public void testKt3579_2() throws Exception { + runTest("compiler/testData/codegen/box/traits/kt3579_2.kt"); + } + + @Test + @TestMetadata("kt36973.kt") + public void testKt36973() throws Exception { + runTest("compiler/testData/codegen/box/traits/kt36973.kt"); + } + + @Test + @TestMetadata("kt5393.kt") + public void testKt5393() throws Exception { + runTest("compiler/testData/codegen/box/traits/kt5393.kt"); + } + + @Test + @TestMetadata("kt5393_property.kt") + public void testKt5393_property() throws Exception { + runTest("compiler/testData/codegen/box/traits/kt5393_property.kt"); + } + + @Test + @TestMetadata("multiple.kt") + public void testMultiple() throws Exception { + runTest("compiler/testData/codegen/box/traits/multiple.kt"); + } + + @Test + @TestMetadata("privateInterfaceMethod.kt") + public void testPrivateInterfaceMethod() throws Exception { + runTest("compiler/testData/codegen/box/traits/privateInterfaceMethod.kt"); + } + + @Test + @TestMetadata("receiverOfIntersectionType.kt") + public void testReceiverOfIntersectionType() throws Exception { + runTest("compiler/testData/codegen/box/traits/receiverOfIntersectionType.kt"); + } + + @Test + @TestMetadata("sameNameMethodFromInterface.kt") + public void testSameNameMethodFromInterface() throws Exception { + runTest("compiler/testData/codegen/box/traits/sameNameMethodFromInterface.kt"); + } + + @Test + @TestMetadata("syntheticAccessor.kt") + public void testSyntheticAccessor() throws Exception { + runTest("compiler/testData/codegen/box/traits/syntheticAccessor.kt"); + } + + @Test + @TestMetadata("traitImplDelegationWithCovariantOverride.kt") + public void testTraitImplDelegationWithCovariantOverride() throws Exception { + runTest("compiler/testData/codegen/box/traits/traitImplDelegationWithCovariantOverride.kt"); + } + + @Test + @TestMetadata("traitImplDiamond.kt") + public void testTraitImplDiamond() throws Exception { + runTest("compiler/testData/codegen/box/traits/traitImplDiamond.kt"); + } + + @Test + @TestMetadata("traitImplGenericDelegation.kt") + public void testTraitImplGenericDelegation() throws Exception { + runTest("compiler/testData/codegen/box/traits/traitImplGenericDelegation.kt"); + } + + @Test + @TestMetadata("traitWithPrivateExtension.kt") + public void testTraitWithPrivateExtension() throws Exception { + runTest("compiler/testData/codegen/box/traits/traitWithPrivateExtension.kt"); + } + + @Test + @TestMetadata("traitWithPrivateMember.kt") + public void testTraitWithPrivateMember() throws Exception { + runTest("compiler/testData/codegen/box/traits/traitWithPrivateMember.kt"); + } + + @Test + @TestMetadata("traitWithPrivateMemberAccessFromLambda.kt") + public void testTraitWithPrivateMemberAccessFromLambda() throws Exception { + runTest("compiler/testData/codegen/box/traits/traitWithPrivateMemberAccessFromLambda.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/typeInfo") + @TestDataPath("$PROJECT_ROOT") + public class TypeInfo { + @Test + public void testAllFilesPresentInTypeInfo() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeInfo"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("ifOrWhenSpecialCall.kt") + public void testIfOrWhenSpecialCall() throws Exception { + runTest("compiler/testData/codegen/box/typeInfo/ifOrWhenSpecialCall.kt"); + } + + @Test + @TestMetadata("implicitSmartCastThis.kt") + public void testImplicitSmartCastThis() throws Exception { + runTest("compiler/testData/codegen/box/typeInfo/implicitSmartCastThis.kt"); + } + + @Test + @TestMetadata("inheritance.kt") + public void testInheritance() throws Exception { + runTest("compiler/testData/codegen/box/typeInfo/inheritance.kt"); + } + + @Test + @TestMetadata("kt2811.kt") + public void testKt2811() throws Exception { + runTest("compiler/testData/codegen/box/typeInfo/kt2811.kt"); + } + + @Test + @TestMetadata("primitiveTypeInfo.kt") + public void testPrimitiveTypeInfo() throws Exception { + runTest("compiler/testData/codegen/box/typeInfo/primitiveTypeInfo.kt"); + } + + @Test + @TestMetadata("smartCastThis.kt") + public void testSmartCastThis() throws Exception { + runTest("compiler/testData/codegen/box/typeInfo/smartCastThis.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/typeMapping") + @TestDataPath("$PROJECT_ROOT") + public class TypeMapping { + @Test + public void testAllFilesPresentInTypeMapping() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typeMapping"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("kt2831.kt") + public void testKt2831() throws Exception { + runTest("compiler/testData/codegen/box/typeMapping/kt2831.kt"); + } + + @Test + @TestMetadata("kt3286.kt") + public void testKt3286() throws Exception { + runTest("compiler/testData/codegen/box/typeMapping/kt3286.kt"); + } + + @Test + @TestMetadata("kt3863.kt") + public void testKt3863() throws Exception { + runTest("compiler/testData/codegen/box/typeMapping/kt3863.kt"); + } + + @Test + @TestMetadata("kt3976.kt") + public void testKt3976() throws Exception { + runTest("compiler/testData/codegen/box/typeMapping/kt3976.kt"); + } + + @Test + @TestMetadata("nothing.kt") + public void testNothing() throws Exception { + runTest("compiler/testData/codegen/box/typeMapping/nothing.kt"); + } + + @Test + @TestMetadata("nullNothing.kt") + public void testNullNothing() throws Exception { + runTest("compiler/testData/codegen/box/typeMapping/nullNothing.kt"); + } + + @Test + @TestMetadata("nullableNothing.kt") + public void testNullableNothing() throws Exception { + runTest("compiler/testData/codegen/box/typeMapping/nullableNothing.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/typealias") + @TestDataPath("$PROJECT_ROOT") + public class Typealias { + @Test + public void testAllFilesPresentInTypealias() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/typealias"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("enumEntryQualifier.kt") + public void testEnumEntryQualifier() throws Exception { + runTest("compiler/testData/codegen/box/typealias/enumEntryQualifier.kt"); + } + + @Test + @TestMetadata("extensionFunction.kt") + public void testExtensionFunction() throws Exception { + runTest("compiler/testData/codegen/box/typealias/extensionFunction.kt"); + } + + @Test + @TestMetadata("genericTypeAliasConstructor.kt") + public void testGenericTypeAliasConstructor() throws Exception { + runTest("compiler/testData/codegen/box/typealias/genericTypeAliasConstructor.kt"); + } + + @Test + @TestMetadata("genericTypeAliasConstructor2.kt") + public void testGenericTypeAliasConstructor2() throws Exception { + runTest("compiler/testData/codegen/box/typealias/genericTypeAliasConstructor2.kt"); + } + + @Test + @TestMetadata("incorrectTypeOfTypealiasForSuspendFTMM.kt") + public void testIncorrectTypeOfTypealiasForSuspendFTMM() throws Exception { + runTest("compiler/testData/codegen/box/typealias/incorrectTypeOfTypealiasForSuspendFTMM.kt"); + } + + @Test + @TestMetadata("incorrectTypeOfTypealiasForSuspendFunctionalType.kt") + public void testIncorrectTypeOfTypealiasForSuspendFunctionalType() throws Exception { + runTest("compiler/testData/codegen/box/typealias/incorrectTypeOfTypealiasForSuspendFunctionalType.kt"); + } + + @Test + @TestMetadata("innerClassTypeAliasConstructor.kt") + public void testInnerClassTypeAliasConstructor() throws Exception { + runTest("compiler/testData/codegen/box/typealias/innerClassTypeAliasConstructor.kt"); + } + + @Test + @TestMetadata("innerClassTypeAliasConstructorInSupertypes.kt") + public void testInnerClassTypeAliasConstructorInSupertypes() throws Exception { + runTest("compiler/testData/codegen/box/typealias/innerClassTypeAliasConstructorInSupertypes.kt"); + } + + @Test + @TestMetadata("kt15109.kt") + public void testKt15109() throws Exception { + runTest("compiler/testData/codegen/box/typealias/kt15109.kt"); + } + + @Test + @TestMetadata("kt45308.kt") + public void testKt45308() throws Exception { + runTest("compiler/testData/codegen/box/typealias/kt45308.kt"); + } + + @Test + @TestMetadata("objectLiteralConstructor.kt") + public void testObjectLiteralConstructor() throws Exception { + runTest("compiler/testData/codegen/box/typealias/objectLiteralConstructor.kt"); + } + + @Test + @TestMetadata("privateInKlib.kt") + public void testPrivateInKlib() throws Exception { + runTest("compiler/testData/codegen/box/typealias/privateInKlib.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/typealias/simple.kt"); + } + + @Test + @TestMetadata("typeAliasAsBareType.kt") + public void testTypeAliasAsBareType() throws Exception { + runTest("compiler/testData/codegen/box/typealias/typeAliasAsBareType.kt"); + } + + @Test + @TestMetadata("typeAliasCompanion.kt") + public void testTypeAliasCompanion() throws Exception { + runTest("compiler/testData/codegen/box/typealias/typeAliasCompanion.kt"); + } + + @Test + @TestMetadata("typeAliasConstructor.kt") + public void testTypeAliasConstructor() throws Exception { + runTest("compiler/testData/codegen/box/typealias/typeAliasConstructor.kt"); + } + + @Test + @TestMetadata("typeAliasConstructorAccessor.kt") + public void testTypeAliasConstructorAccessor() throws Exception { + runTest("compiler/testData/codegen/box/typealias/typeAliasConstructorAccessor.kt"); + } + + @Test + @TestMetadata("typeAliasConstructorForArray.kt") + public void testTypeAliasConstructorForArray() throws Exception { + runTest("compiler/testData/codegen/box/typealias/typeAliasConstructorForArray.kt"); + } + + @Test + @TestMetadata("typeAliasConstructorInSuperCall.kt") + public void testTypeAliasConstructorInSuperCall() throws Exception { + runTest("compiler/testData/codegen/box/typealias/typeAliasConstructorInSuperCall.kt"); + } + + @Test + @TestMetadata("typeAliasFunction.kt") + public void testTypeAliasFunction() throws Exception { + runTest("compiler/testData/codegen/box/typealias/typeAliasFunction.kt"); + } + + @Test + @TestMetadata("typeAliasInAnonymousObjectType.kt") + public void testTypeAliasInAnonymousObjectType() throws Exception { + runTest("compiler/testData/codegen/box/typealias/typeAliasInAnonymousObjectType.kt"); + } + + @Test + @TestMetadata("typeAliasObject.kt") + public void testTypeAliasObject() throws Exception { + runTest("compiler/testData/codegen/box/typealias/typeAliasObject.kt"); + } + + @Test + @TestMetadata("typeAliasObjectCallable.kt") + public void testTypeAliasObjectCallable() throws Exception { + runTest("compiler/testData/codegen/box/typealias/typeAliasObjectCallable.kt"); + } + + @Test + @TestMetadata("typeAliasSecondaryConstructor.kt") + public void testTypeAliasSecondaryConstructor() throws Exception { + runTest("compiler/testData/codegen/box/typealias/typeAliasSecondaryConstructor.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/unaryOp") + @TestDataPath("$PROJECT_ROOT") + public class UnaryOp { + @Test + public void testAllFilesPresentInUnaryOp() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unaryOp"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("call.kt") + public void testCall() throws Exception { + runTest("compiler/testData/codegen/box/unaryOp/call.kt"); + } + + @Test + @TestMetadata("callNullable.kt") + public void testCallNullable() throws Exception { + runTest("compiler/testData/codegen/box/unaryOp/callNullable.kt"); + } + + @Test + @TestMetadata("callWithCommonType.kt") + public void testCallWithCommonType() throws Exception { + runTest("compiler/testData/codegen/box/unaryOp/callWithCommonType.kt"); + } + + @Test + @TestMetadata("intrinsic.kt") + public void testIntrinsic() throws Exception { + runTest("compiler/testData/codegen/box/unaryOp/intrinsic.kt"); + } + + @Test + @TestMetadata("intrinsicNullable.kt") + public void testIntrinsicNullable() throws Exception { + runTest("compiler/testData/codegen/box/unaryOp/intrinsicNullable.kt"); + } + + @Test + @TestMetadata("longOverflow.kt") + public void testLongOverflow() throws Exception { + runTest("compiler/testData/codegen/box/unaryOp/longOverflow.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/underscoredTypeArguments") + @TestDataPath("$PROJECT_ROOT") + public class UnderscoredTypeArguments { + @Test + public void testAllFilesPresentInUnderscoredTypeArguments() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/underscoredTypeArguments"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("backTicked.kt") + public void testBackTicked() throws Exception { + runTest("compiler/testData/codegen/box/underscoredTypeArguments/backTicked.kt"); + } + + @Test + @TestMetadata("lambdaInputType.kt") + public void testLambdaInputType() throws Exception { + runTest("compiler/testData/codegen/box/underscoredTypeArguments/lambdaInputType.kt"); + } + + @Test + @TestMetadata("react.kt") + public void testReact() throws Exception { + runTest("compiler/testData/codegen/box/underscoredTypeArguments/react.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("compiler/testData/codegen/box/underscoredTypeArguments/simple.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/unit") + @TestDataPath("$PROJECT_ROOT") + public class Unit { + @Test + public void testAllFilesPresentInUnit() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unit"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("closureReturnsNullableUnit.kt") + public void testClosureReturnsNullableUnit() throws Exception { + runTest("compiler/testData/codegen/box/unit/closureReturnsNullableUnit.kt"); + } + + @Test + @TestMetadata("ifElse.kt") + public void testIfElse() throws Exception { + runTest("compiler/testData/codegen/box/unit/ifElse.kt"); + } + + @Test + @TestMetadata("kt3634.kt") + public void testKt3634() throws Exception { + runTest("compiler/testData/codegen/box/unit/kt3634.kt"); + } + + @Test + @TestMetadata("kt4212.kt") + public void testKt4212() throws Exception { + runTest("compiler/testData/codegen/box/unit/kt4212.kt"); + } + + @Test + @TestMetadata("kt4265.kt") + public void testKt4265() throws Exception { + runTest("compiler/testData/codegen/box/unit/kt4265.kt"); + } + + @Test + @TestMetadata("kt51036.kt") + public void testKt51036() throws Exception { + runTest("compiler/testData/codegen/box/unit/kt51036.kt"); + } + + @Test + @TestMetadata("kt56723.kt") + public void testKt56723() throws Exception { + runTest("compiler/testData/codegen/box/unit/kt56723.kt"); + } + + @Test + @TestMetadata("nullableUnit.kt") + public void testNullableUnit() throws Exception { + runTest("compiler/testData/codegen/box/unit/nullableUnit.kt"); + } + + @Test + @TestMetadata("nullableUnitInWhen1.kt") + public void testNullableUnitInWhen1() throws Exception { + runTest("compiler/testData/codegen/box/unit/nullableUnitInWhen1.kt"); + } + + @Test + @TestMetadata("nullableUnitInWhen2.kt") + public void testNullableUnitInWhen2() throws Exception { + runTest("compiler/testData/codegen/box/unit/nullableUnitInWhen2.kt"); + } + + @Test + @TestMetadata("nullableUnitInWhen3.kt") + public void testNullableUnitInWhen3() throws Exception { + runTest("compiler/testData/codegen/box/unit/nullableUnitInWhen3.kt"); + } + + @Test + @TestMetadata("sillyThings.kt") + public void testSillyThings() throws Exception { + runTest("compiler/testData/codegen/box/unit/sillyThings.kt"); + } + + @Test + @TestMetadata("unitClassObject.kt") + public void testUnitClassObject() throws Exception { + runTest("compiler/testData/codegen/box/unit/unitClassObject.kt"); + } + + @Test + @TestMetadata("UnitValue.kt") + public void testUnitValue() throws Exception { + runTest("compiler/testData/codegen/box/unit/UnitValue.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/unsignedTypes") + @TestDataPath("$PROJECT_ROOT") + public class UnsignedTypes { + @Test + public void testAllFilesPresentInUnsignedTypes() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("boxConstValOfUnsignedType.kt") + public void testBoxConstValOfUnsignedType() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/boxConstValOfUnsignedType.kt"); + } + + @Test + @TestMetadata("boxedUnsignedEqualsZero.kt") + public void testBoxedUnsignedEqualsZero() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/boxedUnsignedEqualsZero.kt"); + } + + @Test + @TestMetadata("checkBasicUnsignedLiterals.kt") + public void testCheckBasicUnsignedLiterals() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/checkBasicUnsignedLiterals.kt"); + } + + @Test + @TestMetadata("defaultArguments.kt") + public void testDefaultArguments() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/defaultArguments.kt"); + } + + @Test + @TestMetadata("equalsImplForInlineClassWrappingNullableInlineClass.kt") + public void testEqualsImplForInlineClassWrappingNullableInlineClass() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/equalsImplForInlineClassWrappingNullableInlineClass.kt"); + } + + @Test + @TestMetadata("forEachIndexedInListOfUInts.kt") + public void testForEachIndexedInListOfUInts() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/forEachIndexedInListOfUInts.kt"); + } + + @Test + @TestMetadata("forInUnsignedDownTo.kt") + public void testForInUnsignedDownTo() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/forInUnsignedDownTo.kt"); + } + + @Test + @TestMetadata("forInUnsignedProgression.kt") + public void testForInUnsignedProgression() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/forInUnsignedProgression.kt"); + } + + @Test + @TestMetadata("forInUnsignedRange.kt") + public void testForInUnsignedRange() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/forInUnsignedRange.kt"); + } + + @Test + @TestMetadata("forInUnsignedRangeLiteral.kt") + public void testForInUnsignedRangeLiteral() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/forInUnsignedRangeLiteral.kt"); + } + + @Test + @TestMetadata("forInUnsignedRangeWithCoercion.kt") + public void testForInUnsignedRangeWithCoercion() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/forInUnsignedRangeWithCoercion.kt"); + } + + @Test + @TestMetadata("forInUnsignedUntil.kt") + public void testForInUnsignedUntil() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/forInUnsignedUntil.kt"); + } + + @Test + @TestMetadata("implicitIntegerCoercionNamedArg.kt") + public void testImplicitIntegerCoercionNamedArg() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/implicitIntegerCoercionNamedArg.kt"); + } + + @Test + @TestMetadata("inUnsignedDownTo.kt") + public void testInUnsignedDownTo() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/inUnsignedDownTo.kt"); + } + + @Test + @TestMetadata("inUnsignedRange.kt") + public void testInUnsignedRange() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/inUnsignedRange.kt"); + } + + @Test + @TestMetadata("inUnsignedRangeLiteral.kt") + public void testInUnsignedRangeLiteral() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/inUnsignedRangeLiteral.kt"); + } + + @Test + @TestMetadata("inUnsignedUntil.kt") + public void testInUnsignedUntil() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/inUnsignedUntil.kt"); + } + + @Test + @TestMetadata("iterateOverArrayOfUnsignedValues.kt") + public void testIterateOverArrayOfUnsignedValues() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/iterateOverArrayOfUnsignedValues.kt"); + } + + @Test + @TestMetadata("iterateOverListOfBoxedUnsignedValues.kt") + public void testIterateOverListOfBoxedUnsignedValues() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/iterateOverListOfBoxedUnsignedValues.kt"); + } + + @Test + @TestMetadata("kt25784.kt") + public void testKt25784() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/kt25784.kt"); + } + + @Test + @TestMetadata("kt43286.kt") + public void testKt43286() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/kt43286.kt"); + } + + @Test + @TestMetadata("kt43286a.kt") + public void testKt43286a() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/kt43286a.kt"); + } + + @Test + @TestMetadata("kt47716.kt") + public void testKt47716() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/kt47716.kt"); + } + + @Test + @TestMetadata("literalEqualsNullableUnsigned.kt") + public void testLiteralEqualsNullableUnsigned() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/literalEqualsNullableUnsigned.kt"); + } + + @Test + @TestMetadata("nullableUnsignedEqualsLiteral.kt") + public void testNullableUnsignedEqualsLiteral() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/nullableUnsignedEqualsLiteral.kt"); + } + + @Test + @TestMetadata("signedToUnsignedConversions.kt") + public void testSignedToUnsignedConversions() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/signedToUnsignedConversions.kt"); + } + + @Test + @TestMetadata("unsignedArraySize.kt") + public void testUnsignedArraySize() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/unsignedArraySize.kt"); + } + + @Test + @TestMetadata("unsignedIntCompare.kt") + public void testUnsignedIntCompare() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/unsignedIntCompare.kt"); + } + + @Test + @TestMetadata("unsignedIntDivide.kt") + public void testUnsignedIntDivide() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/unsignedIntDivide.kt"); + } + + @Test + @TestMetadata("unsignedIntRemainder.kt") + public void testUnsignedIntRemainder() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/unsignedIntRemainder.kt"); + } + + @Test + @TestMetadata("unsignedIntToString.kt") + public void testUnsignedIntToString() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/unsignedIntToString.kt"); + } + + @Test + @TestMetadata("unsignedLiteralsForMaxLongValue.kt") + public void testUnsignedLiteralsForMaxLongValue() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/unsignedLiteralsForMaxLongValue.kt"); + } + + @Test + @TestMetadata("unsignedLiteralsInApiVersion14.kt") + public void testUnsignedLiteralsInApiVersion14() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/unsignedLiteralsInApiVersion14.kt"); + } + + @Test + @TestMetadata("unsignedLiteralsWithSignedOverflow.kt") + public void testUnsignedLiteralsWithSignedOverflow() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/unsignedLiteralsWithSignedOverflow.kt"); + } + + @Test + @TestMetadata("unsignedLongCompare.kt") + public void testUnsignedLongCompare() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/unsignedLongCompare.kt"); + } + + @Test + @TestMetadata("unsignedLongDivide.kt") + public void testUnsignedLongDivide() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/unsignedLongDivide.kt"); + } + + @Test + @TestMetadata("unsignedLongRemainder.kt") + public void testUnsignedLongRemainder() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/unsignedLongRemainder.kt"); + } + + @Test + @TestMetadata("unsignedLongToString.kt") + public void testUnsignedLongToString() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/unsignedLongToString.kt"); + } + + @Test + @TestMetadata("unsignedRangeIterator.kt") + public void testUnsignedRangeIterator() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/unsignedRangeIterator.kt"); + } + + @Test + @TestMetadata("unsignedToSignedConversion.kt") + public void testUnsignedToSignedConversion() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/unsignedToSignedConversion.kt"); + } + + @Test + @TestMetadata("unsignedTypePrefixIncrementDecrementBoxing.kt") + public void testUnsignedTypePrefixIncrementDecrementBoxing() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/unsignedTypePrefixIncrementDecrementBoxing.kt"); + } + + @Test + @TestMetadata("unsignedTypeValuesInsideStringTemplates.kt") + public void testUnsignedTypeValuesInsideStringTemplates() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/unsignedTypeValuesInsideStringTemplates.kt"); + } + + @Test + @TestMetadata("varargsOfUnsignedTypes.kt") + public void testVarargsOfUnsignedTypes() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/varargsOfUnsignedTypes.kt"); + } + + @Test + @TestMetadata("whenByUnsigned.kt") + public void testWhenByUnsigned() throws Exception { + runTest("compiler/testData/codegen/box/unsignedTypes/whenByUnsigned.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/unsignedTypes/jvm8Intrinsics") + @TestDataPath("$PROJECT_ROOT") + public class Jvm8Intrinsics { + @Test + public void testAllFilesPresentInJvm8Intrinsics() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/unsignedTypes/jvm8Intrinsics"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/valueClasses") + @TestDataPath("$PROJECT_ROOT") + public class ValueClasses { + @Test + public void testAllFilesPresentInValueClasses() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/valueClasses/javaInterop") + @TestDataPath("$PROJECT_ROOT") + public class JavaInterop { + @Test + public void testAllFilesPresentInJavaInterop() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/valueClasses/javaInterop"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/vararg") + @TestDataPath("$PROJECT_ROOT") + public class Vararg { + @Test + public void testAllFilesPresentInVararg() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/vararg"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("boxingArgumentsForVararg.kt") + public void testBoxingArgumentsForVararg() throws Exception { + runTest("compiler/testData/codegen/box/vararg/boxingArgumentsForVararg.kt"); + } + + @Test + @TestMetadata("doNotCopyImmediatelyCreatedArrays.kt") + public void testDoNotCopyImmediatelyCreatedArrays() throws Exception { + runTest("compiler/testData/codegen/box/vararg/doNotCopyImmediatelyCreatedArrays.kt"); + } + + @Test + @TestMetadata("evaluationOrder.kt") + public void testEvaluationOrder() throws Exception { + runTest("compiler/testData/codegen/box/vararg/evaluationOrder.kt"); + } + + @Test + @TestMetadata("kt10926.kt") + public void testKt10926() throws Exception { + runTest("compiler/testData/codegen/box/vararg/kt10926.kt"); + } + + @Test + @TestMetadata("kt1978.kt") + public void testKt1978() throws Exception { + runTest("compiler/testData/codegen/box/vararg/kt1978.kt"); + } + + @Test + @TestMetadata("kt37715.kt") + public void testKt37715() throws Exception { + runTest("compiler/testData/codegen/box/vararg/kt37715.kt"); + } + + @Test + @TestMetadata("kt37779.kt") + public void testKt37779() throws Exception { + runTest("compiler/testData/codegen/box/vararg/kt37779.kt"); + } + + @Test + @TestMetadata("kt581.kt") + public void testKt581() throws Exception { + runTest("compiler/testData/codegen/box/vararg/kt581.kt"); + } + + @Test + @TestMetadata("kt6192.kt") + public void testKt6192() throws Exception { + runTest("compiler/testData/codegen/box/vararg/kt6192.kt"); + } + + @Test + @TestMetadata("kt796_797.kt") + public void testKt796_797() throws Exception { + runTest("compiler/testData/codegen/box/vararg/kt796_797.kt"); + } + + @Test + @TestMetadata("referenceToContainsFromVarargParameter.kt") + public void testReferenceToContainsFromVarargParameter() throws Exception { + runTest("compiler/testData/codegen/box/vararg/referenceToContainsFromVarargParameter.kt"); + } + + @Test + @TestMetadata("singleAssignmentToVarargsInFunction.kt") + public void testSingleAssignmentToVarargsInFunction() throws Exception { + runTest("compiler/testData/codegen/box/vararg/singleAssignmentToVarargsInFunction.kt"); + } + + @Test + @TestMetadata("spreadCopiesArray.kt") + public void testSpreadCopiesArray() throws Exception { + runTest("compiler/testData/codegen/box/vararg/spreadCopiesArray.kt"); + } + + @Test + @TestMetadata("useSuspendFunResultAsVararg.kt") + public void testUseSuspendFunResultAsVararg() throws Exception { + runTest("compiler/testData/codegen/box/vararg/useSuspendFunResultAsVararg.kt"); + } + + @Test + @TestMetadata("varargInFunParam.kt") + public void testVarargInFunParam() throws Exception { + runTest("compiler/testData/codegen/box/vararg/varargInFunParam.kt"); + } + + @Test + @TestMetadata("varargsAndFunctionLiterals.kt") + public void testVarargsAndFunctionLiterals() throws Exception { + runTest("compiler/testData/codegen/box/vararg/varargsAndFunctionLiterals.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/volatile") + @TestDataPath("$PROJECT_ROOT") + public class Volatile { + @Test + public void testAllFilesPresentInVolatile() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/volatile"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("volatileBool.kt") + public void testVolatileBool() throws Exception { + runTest("compiler/testData/codegen/box/volatile/volatileBool.kt"); + } + + @Test + @TestMetadata("volatileByte.kt") + public void testVolatileByte() throws Exception { + runTest("compiler/testData/codegen/box/volatile/volatileByte.kt"); + } + + @Test + @TestMetadata("volatileDouble.kt") + public void testVolatileDouble() throws Exception { + runTest("compiler/testData/codegen/box/volatile/volatileDouble.kt"); + } + + @Test + @TestMetadata("volatileFloat.kt") + public void testVolatileFloat() throws Exception { + runTest("compiler/testData/codegen/box/volatile/volatileFloat.kt"); + } + + @Test + @TestMetadata("volatileGeneric.kt") + public void testVolatileGeneric() throws Exception { + runTest("compiler/testData/codegen/box/volatile/volatileGeneric.kt"); + } + + @Test + @TestMetadata("volatileInt.kt") + public void testVolatileInt() throws Exception { + runTest("compiler/testData/codegen/box/volatile/volatileInt.kt"); + } + + @Test + @TestMetadata("volatileLong.kt") + public void testVolatileLong() throws Exception { + runTest("compiler/testData/codegen/box/volatile/volatileLong.kt"); + } + + @Test + @TestMetadata("volatileShort.kt") + public void testVolatileShort() throws Exception { + runTest("compiler/testData/codegen/box/volatile/volatileShort.kt"); + } + + @Test + @TestMetadata("volatileString.kt") + public void testVolatileString() throws Exception { + runTest("compiler/testData/codegen/box/volatile/volatileString.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/when") + @TestDataPath("$PROJECT_ROOT") + public class When { + @Test + public void testAllFilesPresentInWhen() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("callProperty.kt") + public void testCallProperty() throws Exception { + runTest("compiler/testData/codegen/box/when/callProperty.kt"); + } + + @Test + @TestMetadata("edgeCases.kt") + public void testEdgeCases() throws Exception { + runTest("compiler/testData/codegen/box/when/edgeCases.kt"); + } + + @Test + @TestMetadata("emptyWhen.kt") + public void testEmptyWhen() throws Exception { + runTest("compiler/testData/codegen/box/when/emptyWhen.kt"); + } + + @Test + @TestMetadata("exceptionOnNoMatch.kt") + public void testExceptionOnNoMatch() throws Exception { + runTest("compiler/testData/codegen/box/when/exceptionOnNoMatch.kt"); + } + + @Test + @TestMetadata("exhaustiveBoolean.kt") + public void testExhaustiveBoolean() throws Exception { + runTest("compiler/testData/codegen/box/when/exhaustiveBoolean.kt"); + } + + @Test + @TestMetadata("exhaustiveBreakContinue.kt") + public void testExhaustiveBreakContinue() throws Exception { + runTest("compiler/testData/codegen/box/when/exhaustiveBreakContinue.kt"); + } + + @Test + @TestMetadata("exhaustiveWhenInitialization.kt") + public void testExhaustiveWhenInitialization() throws Exception { + runTest("compiler/testData/codegen/box/when/exhaustiveWhenInitialization.kt"); + } + + @Test + @TestMetadata("exhaustiveWhenReturn.kt") + public void testExhaustiveWhenReturn() throws Exception { + runTest("compiler/testData/codegen/box/when/exhaustiveWhenReturn.kt"); + } + + @Test + @TestMetadata("implicitExhaustiveAndReturn.kt") + public void testImplicitExhaustiveAndReturn() throws Exception { + runTest("compiler/testData/codegen/box/when/implicitExhaustiveAndReturn.kt"); + } + + @Test + @TestMetadata("inferredTypeParameters.kt") + public void testInferredTypeParameters() throws Exception { + runTest("compiler/testData/codegen/box/when/inferredTypeParameters.kt"); + } + + @Test + @TestMetadata("integralWhenWithNoInlinedConstants2.kt") + public void testIntegralWhenWithNoInlinedConstants2() throws Exception { + runTest("compiler/testData/codegen/box/when/integralWhenWithNoInlinedConstants2.kt"); + } + + @Test + @TestMetadata("is.kt") + public void testIs() throws Exception { + runTest("compiler/testData/codegen/box/when/is.kt"); + } + + @Test + @TestMetadata("kt2457.kt") + public void testKt2457() throws Exception { + runTest("compiler/testData/codegen/box/when/kt2457.kt"); + } + + @Test + @TestMetadata("kt2466.kt") + public void testKt2466() throws Exception { + runTest("compiler/testData/codegen/box/when/kt2466.kt"); + } + + @Test + @TestMetadata("kt45081.kt") + public void testKt45081() throws Exception { + runTest("compiler/testData/codegen/box/when/kt45081.kt"); + } + + @Test + @TestMetadata("kt47365.kt") + public void testKt47365() throws Exception { + runTest("compiler/testData/codegen/box/when/kt47365.kt"); + } + + @Test + @TestMetadata("kt5307.kt") + public void testKt5307() throws Exception { + runTest("compiler/testData/codegen/box/when/kt5307.kt"); + } + + @Test + @TestMetadata("kt5448.kt") + public void testKt5448() throws Exception { + runTest("compiler/testData/codegen/box/when/kt5448.kt"); + } + + @Test + @TestMetadata("kt55993.kt") + public void testKt55993() throws Exception { + runTest("compiler/testData/codegen/box/when/kt55993.kt"); + } + + @Test + @TestMetadata("kt59346.kt") + public void testKt59346() throws Exception { + runTest("compiler/testData/codegen/box/when/kt59346.kt"); + } + + @Test + @TestMetadata("longInRange.kt") + public void testLongInRange() throws Exception { + runTest("compiler/testData/codegen/box/when/longInRange.kt"); + } + + @Test + @TestMetadata("matchNotNullAgainstNullable.kt") + public void testMatchNotNullAgainstNullable() throws Exception { + runTest("compiler/testData/codegen/box/when/matchNotNullAgainstNullable.kt"); + } + + @Test + @TestMetadata("multipleEntries.kt") + public void testMultipleEntries() throws Exception { + runTest("compiler/testData/codegen/box/when/multipleEntries.kt"); + } + + @Test + @TestMetadata("noElseCoerceToUnit.kt") + public void testNoElseCoerceToUnit() throws Exception { + runTest("compiler/testData/codegen/box/when/noElseCoerceToUnit.kt"); + } + + @Test + @TestMetadata("noElseExhaustive.kt") + public void testNoElseExhaustive() throws Exception { + runTest("compiler/testData/codegen/box/when/noElseExhaustive.kt"); + } + + @Test + @TestMetadata("noElseExhaustiveStatement.kt") + public void testNoElseExhaustiveStatement() throws Exception { + runTest("compiler/testData/codegen/box/when/noElseExhaustiveStatement.kt"); + } + + @Test + @TestMetadata("noElseExhaustiveUnitExpected.kt") + public void testNoElseExhaustiveUnitExpected() throws Exception { + runTest("compiler/testData/codegen/box/when/noElseExhaustiveUnitExpected.kt"); + } + + @Test + @TestMetadata("noElseInStatement.kt") + public void testNoElseInStatement() throws Exception { + runTest("compiler/testData/codegen/box/when/noElseInStatement.kt"); + } + + @Test + @TestMetadata("noElseNoMatch.kt") + public void testNoElseNoMatch() throws Exception { + runTest("compiler/testData/codegen/box/when/noElseNoMatch.kt"); + } + + @Test + @TestMetadata("nullableWhen.kt") + public void testNullableWhen() throws Exception { + runTest("compiler/testData/codegen/box/when/nullableWhen.kt"); + } + + @Test + @TestMetadata("range.kt") + public void testRange() throws Exception { + runTest("compiler/testData/codegen/box/when/range.kt"); + } + + @Test + @TestMetadata("sealedWhenInitialization.kt") + public void testSealedWhenInitialization() throws Exception { + runTest("compiler/testData/codegen/box/when/sealedWhenInitialization.kt"); + } + + @Test + @TestMetadata("switchBreakNoLabel.kt") + public void testSwitchBreakNoLabel() throws Exception { + runTest("compiler/testData/codegen/box/when/switchBreakNoLabel.kt"); + } + + @Test + @TestMetadata("switchOptimizationDense.kt") + public void testSwitchOptimizationDense() throws Exception { + runTest("compiler/testData/codegen/box/when/switchOptimizationDense.kt"); + } + + @Test + @TestMetadata("switchOptimizationDuplicates.kt") + public void testSwitchOptimizationDuplicates() throws Exception { + runTest("compiler/testData/codegen/box/when/switchOptimizationDuplicates.kt"); + } + + @Test + @TestMetadata("switchOptimizationMultipleConditions.kt") + public void testSwitchOptimizationMultipleConditions() throws Exception { + runTest("compiler/testData/codegen/box/when/switchOptimizationMultipleConditions.kt"); + } + + @Test + @TestMetadata("switchOptimizationMultipleMixedConditions.kt") + public void testSwitchOptimizationMultipleMixedConditions() throws Exception { + runTest("compiler/testData/codegen/box/when/switchOptimizationMultipleMixedConditions.kt"); + } + + @Test + @TestMetadata("switchOptimizationSingleStatementCase.kt") + public void testSwitchOptimizationSingleStatementCase() throws Exception { + runTest("compiler/testData/codegen/box/when/switchOptimizationSingleStatementCase.kt"); + } + + @Test + @TestMetadata("switchOptimizationSparse.kt") + public void testSwitchOptimizationSparse() throws Exception { + runTest("compiler/testData/codegen/box/when/switchOptimizationSparse.kt"); + } + + @Test + @TestMetadata("switchOptimizationStatement.kt") + public void testSwitchOptimizationStatement() throws Exception { + runTest("compiler/testData/codegen/box/when/switchOptimizationStatement.kt"); + } + + @Test + @TestMetadata("switchOptimizationTypes.kt") + public void testSwitchOptimizationTypes() throws Exception { + runTest("compiler/testData/codegen/box/when/switchOptimizationTypes.kt"); + } + + @Test + @TestMetadata("switchOptimizationUnordered.kt") + public void testSwitchOptimizationUnordered() throws Exception { + runTest("compiler/testData/codegen/box/when/switchOptimizationUnordered.kt"); + } + + @Test + @TestMetadata("switchOptimizationWithGap.kt") + public void testSwitchOptimizationWithGap() throws Exception { + runTest("compiler/testData/codegen/box/when/switchOptimizationWithGap.kt"); + } + + @Test + @TestMetadata("typeDisjunction.kt") + public void testTypeDisjunction() throws Exception { + runTest("compiler/testData/codegen/box/when/typeDisjunction.kt"); + } + + @Test + @TestMetadata("whenArgumentIsEvaluatedOnlyOnce.kt") + public void testWhenArgumentIsEvaluatedOnlyOnce() throws Exception { + runTest("compiler/testData/codegen/box/when/whenArgumentIsEvaluatedOnlyOnce.kt"); + } + + @Test + @TestMetadata("whenSafeCallSubjectEvaluatedOnce.kt") + public void testWhenSafeCallSubjectEvaluatedOnce() throws Exception { + runTest("compiler/testData/codegen/box/when/whenSafeCallSubjectEvaluatedOnce.kt"); + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/when/enumOptimization") + @TestDataPath("$PROJECT_ROOT") + public class EnumOptimization { + @Test + public void testAllFilesPresentInEnumOptimization() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/enumOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("bigEnum.kt") + public void testBigEnum() throws Exception { + runTest("compiler/testData/codegen/box/when/enumOptimization/bigEnum.kt"); + } + + @Test + @TestMetadata("differentEnumClasses.kt") + public void testDifferentEnumClasses() throws Exception { + runTest("compiler/testData/codegen/box/when/enumOptimization/differentEnumClasses.kt"); + } + + @Test + @TestMetadata("differentEnumClasses2.kt") + public void testDifferentEnumClasses2() throws Exception { + runTest("compiler/testData/codegen/box/when/enumOptimization/differentEnumClasses2.kt"); + } + + @Test + @TestMetadata("duplicatingItems.kt") + public void testDuplicatingItems() throws Exception { + runTest("compiler/testData/codegen/box/when/enumOptimization/duplicatingItems.kt"); + } + + @Test + @TestMetadata("enumInsideClassObject.kt") + public void testEnumInsideClassObject() throws Exception { + runTest("compiler/testData/codegen/box/when/enumOptimization/enumInsideClassObject.kt"); + } + + @Test + @TestMetadata("expression.kt") + public void testExpression() throws Exception { + runTest("compiler/testData/codegen/box/when/enumOptimization/expression.kt"); + } + + @Test + @TestMetadata("functionLiteralInTopLevel.kt") + public void testFunctionLiteralInTopLevel() throws Exception { + runTest("compiler/testData/codegen/box/when/enumOptimization/functionLiteralInTopLevel.kt"); + } + + @Test + @TestMetadata("kt14597.kt") + public void testKt14597() throws Exception { + runTest("compiler/testData/codegen/box/when/enumOptimization/kt14597.kt"); + } + + @Test + @TestMetadata("kt14597_full.kt") + public void testKt14597_full() throws Exception { + runTest("compiler/testData/codegen/box/when/enumOptimization/kt14597_full.kt"); + } + + @Test + @TestMetadata("kt14802.kt") + public void testKt14802() throws Exception { + runTest("compiler/testData/codegen/box/when/enumOptimization/kt14802.kt"); + } + + @Test + @TestMetadata("kt15806.kt") + public void testKt15806() throws Exception { + runTest("compiler/testData/codegen/box/when/enumOptimization/kt15806.kt"); + } + + @Test + @TestMetadata("kt50258.kt") + public void testKt50258() throws Exception { + runTest("compiler/testData/codegen/box/when/enumOptimization/kt50258.kt"); + } + + @Test + @TestMetadata("manyWhensWithinClass.kt") + public void testManyWhensWithinClass() throws Exception { + runTest("compiler/testData/codegen/box/when/enumOptimization/manyWhensWithinClass.kt"); + } + + @Test + @TestMetadata("nestedWhenInCondition.kt") + public void testNestedWhenInCondition() throws Exception { + runTest("compiler/testData/codegen/box/when/enumOptimization/nestedWhenInCondition.kt"); + } + + @Test + @TestMetadata("nestedWhenInResult.kt") + public void testNestedWhenInResult() throws Exception { + runTest("compiler/testData/codegen/box/when/enumOptimization/nestedWhenInResult.kt"); + } + + @Test + @TestMetadata("nonConstantEnum.kt") + public void testNonConstantEnum() throws Exception { + runTest("compiler/testData/codegen/box/when/enumOptimization/nonConstantEnum.kt"); + } + + @Test + @TestMetadata("nullIsTheFirstEntry.kt") + public void testNullIsTheFirstEntry() throws Exception { + runTest("compiler/testData/codegen/box/when/enumOptimization/nullIsTheFirstEntry.kt"); + } + + @Test + @TestMetadata("nullability.kt") + public void testNullability() throws Exception { + runTest("compiler/testData/codegen/box/when/enumOptimization/nullability.kt"); + } + + @Test + @TestMetadata("nullableEnum.kt") + public void testNullableEnum() throws Exception { + runTest("compiler/testData/codegen/box/when/enumOptimization/nullableEnum.kt"); + } + + @Test + @TestMetadata("subjectAny.kt") + public void testSubjectAny() throws Exception { + runTest("compiler/testData/codegen/box/when/enumOptimization/subjectAny.kt"); + } + + @Test + @TestMetadata("withoutElse.kt") + public void testWithoutElse() throws Exception { + runTest("compiler/testData/codegen/box/when/enumOptimization/withoutElse.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/when/stringOptimization") + @TestDataPath("$PROJECT_ROOT") + public class StringOptimization { + @Test + public void testAllFilesPresentInStringOptimization() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/stringOptimization"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("duplicatingItems.kt") + public void testDuplicatingItems() throws Exception { + runTest("compiler/testData/codegen/box/when/stringOptimization/duplicatingItems.kt"); + } + + @Test + @TestMetadata("duplicatingItemsSameHashCode.kt") + public void testDuplicatingItemsSameHashCode() throws Exception { + runTest("compiler/testData/codegen/box/when/stringOptimization/duplicatingItemsSameHashCode.kt"); + } + + @Test + @TestMetadata("duplicatingItemsSameHashCode2.kt") + public void testDuplicatingItemsSameHashCode2() throws Exception { + runTest("compiler/testData/codegen/box/when/stringOptimization/duplicatingItemsSameHashCode2.kt"); + } + + @Test + @TestMetadata("duplicatingItemsSameHashCode3.kt") + public void testDuplicatingItemsSameHashCode3() throws Exception { + runTest("compiler/testData/codegen/box/when/stringOptimization/duplicatingItemsSameHashCode3.kt"); + } + + @Test + @TestMetadata("expression.kt") + public void testExpression() throws Exception { + runTest("compiler/testData/codegen/box/when/stringOptimization/expression.kt"); + } + + @Test + @TestMetadata("nullability.kt") + public void testNullability() throws Exception { + runTest("compiler/testData/codegen/box/when/stringOptimization/nullability.kt"); + } + + @Test + @TestMetadata("sameHashCode.kt") + public void testSameHashCode() throws Exception { + runTest("compiler/testData/codegen/box/when/stringOptimization/sameHashCode.kt"); + } + + @Test + @TestMetadata("statement.kt") + public void testStatement() throws Exception { + runTest("compiler/testData/codegen/box/when/stringOptimization/statement.kt"); + } + + @Test + @TestMetadata("temporaryVarInWhenByStringIsDisposedProperly.kt") + public void testTemporaryVarInWhenByStringIsDisposedProperly() throws Exception { + runTest("compiler/testData/codegen/box/when/stringOptimization/temporaryVarInWhenByStringIsDisposedProperly.kt"); + } + } + + @Nested + @TestMetadata("compiler/testData/codegen/box/when/whenSubjectVariable") + @TestDataPath("$PROJECT_ROOT") + public class WhenSubjectVariable { + @Test + public void testAllFilesPresentInWhenSubjectVariable() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/box/when/whenSubjectVariable"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("captureSubjectVariable.kt") + public void testCaptureSubjectVariable() throws Exception { + runTest("compiler/testData/codegen/box/when/whenSubjectVariable/captureSubjectVariable.kt"); + } + + @Test + @TestMetadata("denseIntSwitchWithSubjectVariable.kt") + public void testDenseIntSwitchWithSubjectVariable() throws Exception { + runTest("compiler/testData/codegen/box/when/whenSubjectVariable/denseIntSwitchWithSubjectVariable.kt"); + } + + @Test + @TestMetadata("equalityWithSubjectVariable.kt") + public void testEqualityWithSubjectVariable() throws Exception { + runTest("compiler/testData/codegen/box/when/whenSubjectVariable/equalityWithSubjectVariable.kt"); + } + + @Test + @TestMetadata("ieee754Equality.kt") + public void testIeee754Equality() throws Exception { + runTest("compiler/testData/codegen/box/when/whenSubjectVariable/ieee754Equality.kt"); + } + + @Test + @TestMetadata("ieee754EqualityWithSmartCast.kt") + public void testIeee754EqualityWithSmartCast() throws Exception { + runTest("compiler/testData/codegen/box/when/whenSubjectVariable/ieee754EqualityWithSmartCast.kt"); + } + + @Test + @TestMetadata("isCheckOnSubjectVariable.kt") + public void testIsCheckOnSubjectVariable() throws Exception { + runTest("compiler/testData/codegen/box/when/whenSubjectVariable/isCheckOnSubjectVariable.kt"); + } + + @Test + @TestMetadata("kt27161.kt") + public void testKt27161() throws Exception { + runTest("compiler/testData/codegen/box/when/whenSubjectVariable/kt27161.kt"); + } + + @Test + @TestMetadata("kt27161_int.kt") + public void testKt27161_int() throws Exception { + runTest("compiler/testData/codegen/box/when/whenSubjectVariable/kt27161_int.kt"); + } + + @Test + @TestMetadata("kt27161_nested.kt") + public void testKt27161_nested() throws Exception { + runTest("compiler/testData/codegen/box/when/whenSubjectVariable/kt27161_nested.kt"); + } + + @Test + @TestMetadata("kt27161_nested2.kt") + public void testKt27161_nested2() throws Exception { + runTest("compiler/testData/codegen/box/when/whenSubjectVariable/kt27161_nested2.kt"); + } + + @Test + @TestMetadata("kt27161_string.kt") + public void testKt27161_string() throws Exception { + runTest("compiler/testData/codegen/box/when/whenSubjectVariable/kt27161_string.kt"); + } + + @Test + @TestMetadata("kt33641_inlineClass.kt") + public void testKt33641_inlineClass() throws Exception { + runTest("compiler/testData/codegen/box/when/whenSubjectVariable/kt33641_inlineClass.kt"); + } + + @Test + @TestMetadata("rangeCheckOnSubjectVariable.kt") + public void testRangeCheckOnSubjectVariable() throws Exception { + runTest("compiler/testData/codegen/box/when/whenSubjectVariable/rangeCheckOnSubjectVariable.kt"); + } + + @Test + @TestMetadata("sparseIntSwitchWithSubjectVariable.kt") + public void testSparseIntSwitchWithSubjectVariable() throws Exception { + runTest("compiler/testData/codegen/box/when/whenSubjectVariable/sparseIntSwitchWithSubjectVariable.kt"); + } + + @Test + @TestMetadata("subjectExpressionIsEvaluatedOnce.kt") + public void testSubjectExpressionIsEvaluatedOnce() throws Exception { + runTest("compiler/testData/codegen/box/when/whenSubjectVariable/subjectExpressionIsEvaluatedOnce.kt"); + } + + @Test + @TestMetadata("whenByEnum.kt") + public void testWhenByEnum() throws Exception { + runTest("compiler/testData/codegen/box/when/whenSubjectVariable/whenByEnum.kt"); + } + + @Test + @TestMetadata("whenByNullableEnum.kt") + public void testWhenByNullableEnum() throws Exception { + runTest("compiler/testData/codegen/box/when/whenSubjectVariable/whenByNullableEnum.kt"); + } + + @Test + @TestMetadata("whenByString.kt") + public void testWhenByString() throws Exception { + runTest("compiler/testData/codegen/box/when/whenSubjectVariable/whenByString.kt"); + } + } + } +} diff --git a/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/K1WasmCodegenWasmJsInteropTestGenerated.java b/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/K1WasmCodegenWasmJsInteropTestGenerated.java new file mode 100644 index 00000000000..5d2fdf0423a --- /dev/null +++ b/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/K1WasmCodegenWasmJsInteropTestGenerated.java @@ -0,0 +1,159 @@ +/* + * Copyright 2010-2023 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.wasm.test; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.util.KtTestUtil; +import org.jetbrains.kotlin.test.TargetBackend; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.GenerateWasmTestsKt}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("compiler/testData/codegen/boxWasmJsInterop") +@TestDataPath("$PROJECT_ROOT") +public class K1WasmCodegenWasmJsInteropTestGenerated extends AbstractK1WasmCodegenWasmJsInteropTest { + @Test + public void testAllFilesPresentInBoxWasmJsInterop() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/codegen/boxWasmJsInterop"), Pattern.compile("^(.+)\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("callingWasmDirectly.kt") + public void testCallingWasmDirectly() throws Exception { + runTest("compiler/testData/codegen/boxWasmJsInterop/callingWasmDirectly.kt"); + } + + @Test + @TestMetadata("defaultValues.kt") + public void testDefaultValues() throws Exception { + runTest("compiler/testData/codegen/boxWasmJsInterop/defaultValues.kt"); + } + + @Test + @TestMetadata("externalTypeOperators.kt") + public void testExternalTypeOperators() throws Exception { + runTest("compiler/testData/codegen/boxWasmJsInterop/externalTypeOperators.kt"); + } + + @Test + @TestMetadata("externals.kt") + public void testExternals() throws Exception { + runTest("compiler/testData/codegen/boxWasmJsInterop/externals.kt"); + } + + @Test + @TestMetadata("functionTypes.kt") + public void testFunctionTypes() throws Exception { + runTest("compiler/testData/codegen/boxWasmJsInterop/functionTypes.kt"); + } + + @Test + @TestMetadata("imperativeWrapperInitialised.kt") + public void testImperativeWrapperInitialised() throws Exception { + runTest("compiler/testData/codegen/boxWasmJsInterop/imperativeWrapperInitialised.kt"); + } + + @Test + @TestMetadata("imperativeWrapperUninitialised.kt") + public void testImperativeWrapperUninitialised() throws Exception { + runTest("compiler/testData/codegen/boxWasmJsInterop/imperativeWrapperUninitialised.kt"); + } + + @Test + @TestMetadata("jsCode.kt") + public void testJsCode() throws Exception { + runTest("compiler/testData/codegen/boxWasmJsInterop/jsCode.kt"); + } + + @Test + @TestMetadata("jsExport.kt") + public void testJsExport() throws Exception { + runTest("compiler/testData/codegen/boxWasmJsInterop/jsExport.kt"); + } + + @Test + @TestMetadata("jsModule.kt") + public void testJsModule() throws Exception { + runTest("compiler/testData/codegen/boxWasmJsInterop/jsModule.kt"); + } + + @Test + @TestMetadata("jsModuleWithQualifier.kt") + public void testJsModuleWithQualifier() throws Exception { + runTest("compiler/testData/codegen/boxWasmJsInterop/jsModuleWithQualifier.kt"); + } + + @Test + @TestMetadata("jsQualifier.kt") + public void testJsQualifier() throws Exception { + runTest("compiler/testData/codegen/boxWasmJsInterop/jsQualifier.kt"); + } + + @Test + @TestMetadata("jsToKotlinAdapters.kt") + public void testJsToKotlinAdapters() throws Exception { + runTest("compiler/testData/codegen/boxWasmJsInterop/jsToKotlinAdapters.kt"); + } + + @Test + @TestMetadata("jsTypes.kt") + public void testJsTypes() throws Exception { + runTest("compiler/testData/codegen/boxWasmJsInterop/jsTypes.kt"); + } + + @Test + @TestMetadata("kotlinToJsAdapters.kt") + public void testKotlinToJsAdapters() throws Exception { + runTest("compiler/testData/codegen/boxWasmJsInterop/kotlinToJsAdapters.kt"); + } + + @Test + @TestMetadata("lambdaAdapterNameClash.kt") + public void testLambdaAdapterNameClash() throws Exception { + runTest("compiler/testData/codegen/boxWasmJsInterop/lambdaAdapterNameClash.kt"); + } + + @Test + @TestMetadata("longStrings.kt") + public void testLongStrings() throws Exception { + runTest("compiler/testData/codegen/boxWasmJsInterop/longStrings.kt"); + } + + @Test + @TestMetadata("nameClash.kt") + public void testNameClash() throws Exception { + runTest("compiler/testData/codegen/boxWasmJsInterop/nameClash.kt"); + } + + @Test + @TestMetadata("nullableExternRefs.kt") + public void testNullableExternRefs() throws Exception { + runTest("compiler/testData/codegen/boxWasmJsInterop/nullableExternRefs.kt"); + } + + @Test + @TestMetadata("types.kt") + public void testTypes() throws Exception { + runTest("compiler/testData/codegen/boxWasmJsInterop/types.kt"); + } + + @Test + @TestMetadata("vararg.kt") + public void testVararg() throws Exception { + runTest("compiler/testData/codegen/boxWasmJsInterop/vararg.kt"); + } + + @Test + @TestMetadata("wasmImport.kt") + public void testWasmImport() throws Exception { + runTest("compiler/testData/codegen/boxWasmJsInterop/wasmImport.kt"); + } +} diff --git a/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/JsTranslatorWasmTestGenerated.java b/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/K1WasmJsTranslatorTestGenerated.java similarity index 80% rename from wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/JsTranslatorWasmTestGenerated.java rename to wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/K1WasmJsTranslatorTestGenerated.java index 52394ce0217..bd716dd2eb5 100644 --- a/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/JsTranslatorWasmTestGenerated.java +++ b/wasm/wasm.tests/tests-gen/org/jetbrains/kotlin/wasm/test/K1WasmJsTranslatorTestGenerated.java @@ -6,329 +6,351 @@ package org.jetbrains.kotlin.wasm.test; import com.intellij.testFramework.TestDataPath; -import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; -import org.jetbrains.kotlin.test.KotlinTestUtils; import org.jetbrains.kotlin.test.util.KtTestUtil; import org.jetbrains.kotlin.test.TargetBackend; import org.jetbrains.kotlin.test.TestMetadata; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; import java.io.File; import java.util.regex.Pattern; /** This class is generated by {@link org.jetbrains.kotlin.generators.tests.GenerateWasmTestsKt}. DO NOT MODIFY MANUALLY */ @SuppressWarnings("all") -@RunWith(JUnit3RunnerWithInners.class) -public class JsTranslatorWasmTestGenerated extends AbstractJsTranslatorWasmTest { +public class K1WasmJsTranslatorTestGenerated extends AbstractK1WasmJsTranslatorTest { + @Nested @TestMetadata("js/js.translator/testData/box/main") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Main extends AbstractJsTranslatorWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Main { + @Test public void testAllFilesPresentInMain() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/main"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("differentMains.kt") public void testDifferentMains() throws Exception { runTest("js/js.translator/testData/box/main/differentMains.kt"); } + @Test @TestMetadata("incremental.kt") public void testIncremental() throws Exception { runTest("js/js.translator/testData/box/main/incremental.kt"); } + @Test @TestMetadata("noArgs.kt") public void testNoArgs() throws Exception { runTest("js/js.translator/testData/box/main/noArgs.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("js/js.translator/testData/box/main/simple.kt"); } + @Test @TestMetadata("suspendMain.kt") public void testSuspendMain() throws Exception { runTest("js/js.translator/testData/box/main/suspendMain.kt"); } + @Test @TestMetadata("suspendMainNoArgs.kt") public void testSuspendMainNoArgs() throws Exception { runTest("js/js.translator/testData/box/main/suspendMainNoArgs.kt"); } + @Test @TestMetadata("suspendMainThrows.kt") public void testSuspendMainThrows() throws Exception { runTest("js/js.translator/testData/box/main/suspendMainThrows.kt"); } + @Test @TestMetadata("twoMains.kt") public void testTwoMains() throws Exception { runTest("js/js.translator/testData/box/main/twoMains.kt"); } } + @Nested @TestMetadata("js/js.translator/testData/box/native") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Native extends AbstractJsTranslatorWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Native { + @Test @TestMetadata("accessToCompanionObjectFromInlineFun.kt") public void testAccessToCompanionObjectFromInlineFun() throws Exception { runTest("js/js.translator/testData/box/native/accessToCompanionObjectFromInlineFun.kt"); } + @Test public void testAllFilesPresentInNative() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/native"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("castToNativeClassChecked.kt") public void testCastToNativeClassChecked() throws Exception { runTest("js/js.translator/testData/box/native/castToNativeClassChecked.kt"); } + @Test @TestMetadata("castToNativeInterface.kt") public void testCastToNativeInterface() throws Exception { runTest("js/js.translator/testData/box/native/castToNativeInterface.kt"); } + @Test @TestMetadata("castToNativeInterfaceChecked.kt") public void testCastToNativeInterfaceChecked() throws Exception { runTest("js/js.translator/testData/box/native/castToNativeInterfaceChecked.kt"); } + @Test @TestMetadata("castToNullableNativeInterface.kt") public void testCastToNullableNativeInterface() throws Exception { runTest("js/js.translator/testData/box/native/castToNullableNativeInterface.kt"); } + @Test @TestMetadata("castToTypeParamBoundedByNativeInterface.kt") public void testCastToTypeParamBoundedByNativeInterface() throws Exception { runTest("js/js.translator/testData/box/native/castToTypeParamBoundedByNativeInterface.kt"); } + @Test @TestMetadata("class.kt") public void testClass() throws Exception { runTest("js/js.translator/testData/box/native/class.kt"); } + @Test @TestMetadata("classObject.kt") public void testClassObject() throws Exception { runTest("js/js.translator/testData/box/native/classObject.kt"); } + @Test @TestMetadata("externalValWithOverridenVar.kt") public void testExternalValWithOverridenVar() throws Exception { runTest("js/js.translator/testData/box/native/externalValWithOverridenVar.kt"); } + @Test @TestMetadata("kt2209.kt") public void testKt2209() throws Exception { runTest("js/js.translator/testData/box/native/kt2209.kt"); } + @Test @TestMetadata("nestedElements.kt") public void testNestedElements() throws Exception { runTest("js/js.translator/testData/box/native/nestedElements.kt"); } + @Test @TestMetadata("objectFunWithVararg.kt") public void testObjectFunWithVararg() throws Exception { runTest("js/js.translator/testData/box/native/objectFunWithVararg.kt"); } + @Test @TestMetadata("passExtLambdaToNative.kt") public void testPassExtLambdaToNative() throws Exception { runTest("js/js.translator/testData/box/native/passExtLambdaToNative.kt"); } + @Test @TestMetadata("passMemberOrExtFromNative.kt") public void testPassMemberOrExtFromNative() throws Exception { runTest("js/js.translator/testData/box/native/passMemberOrExtFromNative.kt"); } + @Test @TestMetadata("passMemberOrExtToNative.kt") public void testPassMemberOrExtToNative() throws Exception { runTest("js/js.translator/testData/box/native/passMemberOrExtToNative.kt"); } + @Test @TestMetadata("passTopLevelFunctionFromNative.kt") public void testPassTopLevelFunctionFromNative() throws Exception { runTest("js/js.translator/testData/box/native/passTopLevelFunctionFromNative.kt"); } + @Test @TestMetadata("passTopLevelOrLocalFunctionToNative.kt") public void testPassTopLevelOrLocalFunctionToNative() throws Exception { runTest("js/js.translator/testData/box/native/passTopLevelOrLocalFunctionToNative.kt"); } + @Test @TestMetadata("privateExternal.kt") public void testPrivateExternal() throws Exception { runTest("js/js.translator/testData/box/native/privateExternal.kt"); } + @Test @TestMetadata("safeCastToNativeInterface.kt") public void testSafeCastToNativeInterface() throws Exception { runTest("js/js.translator/testData/box/native/safeCastToNativeInterface.kt"); } + @Test @TestMetadata("secondaryConstructor.kt") public void testSecondaryConstructor() throws Exception { runTest("js/js.translator/testData/box/native/secondaryConstructor.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("js/js.translator/testData/box/native/simple.kt"); } + @Test @TestMetadata("simpleUndefined.kt") public void testSimpleUndefined() throws Exception { runTest("js/js.translator/testData/box/native/simpleUndefined.kt"); } + @Test @TestMetadata("useClassFromInlineFun.kt") public void testUseClassFromInlineFun() throws Exception { runTest("js/js.translator/testData/box/native/useClassFromInlineFun.kt"); } + @Test @TestMetadata("vararg.kt") public void testVararg() throws Exception { runTest("js/js.translator/testData/box/native/vararg.kt"); } } + @Nested @TestMetadata("js/js.translator/testData/box/esModules") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class EsModules extends AbstractJsTranslatorWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class EsModules { + @Test public void testAllFilesPresentInEsModules() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/esModules"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true, "jsExport", "native", "export", "crossModuleRef", "crossModuleRefPerFile", "crossModuleRefPerModule"); } + @Nested @TestMetadata("js/js.translator/testData/box/esModules/incremental") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Incremental extends AbstractJsTranslatorWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Incremental { + @Test public void testAllFilesPresentInIncremental() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/esModules/incremental"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("jsModule.kt") public void testJsModule() throws Exception { runTest("js/js.translator/testData/box/esModules/incremental/jsModule.kt"); } } + @Nested @TestMetadata("js/js.translator/testData/box/esModules/inline") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Inline extends AbstractJsTranslatorWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Inline { + @Test public void testAllFilesPresentInInline() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/esModules/inline"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } } + @Nested @TestMetadata("js/js.translator/testData/box/esModules/jsModule") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class JsModule extends AbstractJsTranslatorWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class JsModule { + @Test public void testAllFilesPresentInJsModule() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/esModules/jsModule"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("externalClass.kt") public void testExternalClass() throws Exception { runTest("js/js.translator/testData/box/esModules/jsModule/externalClass.kt"); } + @Test @TestMetadata("externalClassNameClash.kt") public void testExternalClassNameClash() throws Exception { runTest("js/js.translator/testData/box/esModules/jsModule/externalClassNameClash.kt"); } + @Test @TestMetadata("externalFunction.kt") public void testExternalFunction() throws Exception { runTest("js/js.translator/testData/box/esModules/jsModule/externalFunction.kt"); } + @Test @TestMetadata("externalFunctionNameClash.kt") public void testExternalFunctionNameClash() throws Exception { runTest("js/js.translator/testData/box/esModules/jsModule/externalFunctionNameClash.kt"); } + @Test @TestMetadata("externalObject.kt") public void testExternalObject() throws Exception { runTest("js/js.translator/testData/box/esModules/jsModule/externalObject.kt"); } + @Test @TestMetadata("externalPackage.kt") public void testExternalPackage() throws Exception { runTest("js/js.translator/testData/box/esModules/jsModule/externalPackage.kt"); } + @Test @TestMetadata("externalPackageInDifferentFile.kt") public void testExternalPackageInDifferentFile() throws Exception { runTest("js/js.translator/testData/box/esModules/jsModule/externalPackageInDifferentFile.kt"); } + @Test @TestMetadata("externalProperty.kt") public void testExternalProperty() throws Exception { runTest("js/js.translator/testData/box/esModules/jsModule/externalProperty.kt"); } + @Test @TestMetadata("interfaces.kt") public void testInterfaces() throws Exception { runTest("js/js.translator/testData/box/esModules/jsModule/interfaces.kt"); } + @Test @TestMetadata("topLevelVarargFun.kt") public void testTopLevelVarargFun() throws Exception { runTest("js/js.translator/testData/box/esModules/jsModule/topLevelVarargFun.kt"); } } + @Nested @TestMetadata("js/js.translator/testData/box/esModules/jsName") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class JsName extends AbstractJsTranslatorWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class JsName { + @Test public void testAllFilesPresentInJsName() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/esModules/jsName"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("defaultJsName.kt") public void testDefaultJsName() throws Exception { runTest("js/js.translator/testData/box/esModules/jsName/defaultJsName.kt"); } + @Test @TestMetadata("jsTopLevelClashes.kt") public void testJsTopLevelClashes() throws Exception { runTest("js/js.translator/testData/box/esModules/jsName/jsTopLevelClashes.kt"); @@ -336,54 +358,117 @@ public class JsTranslatorWasmTestGenerated extends AbstractJsTranslatorWasmTest } } + @Nested @TestMetadata("js/js.translator/testData/box/jsQualifier") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class JsQualifier extends AbstractJsTranslatorWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class JsQualifier { + @Test public void testAllFilesPresentInJsQualifier() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/jsQualifier"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("classes.kt") public void testClasses() throws Exception { runTest("js/js.translator/testData/box/jsQualifier/classes.kt"); } + @Test @TestMetadata("interfaces.kt") public void testInterfaces() throws Exception { runTest("js/js.translator/testData/box/jsQualifier/interfaces.kt"); } + @Test @TestMetadata("simple.kt") public void testSimple() throws Exception { runTest("js/js.translator/testData/box/jsQualifier/simple.kt"); } } + @Nested @TestMetadata("js/js.translator/testData/box/reflection") @TestDataPath("$PROJECT_ROOT") - @RunWith(JUnit3RunnerWithInners.class) - public static class Reflection extends AbstractJsTranslatorWasmTest { - private void runTest(String testDataFilePath) throws Exception { - KotlinTestUtils.runTest0(this::doTest, TargetBackend.WASM, testDataFilePath); - } - + public class Reflection { + @Test public void testAllFilesPresentInReflection() throws Exception { KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/reflection"), Pattern.compile("^(findAssociatedObject(InSeparatedFile)?)\\.kt$"), null, TargetBackend.WASM, true); } + @Test @TestMetadata("findAssociatedObject.kt") public void testFindAssociatedObject() throws Exception { runTest("js/js.translator/testData/box/reflection/findAssociatedObject.kt"); } + @Test @TestMetadata("findAssociatedObjectInSeparatedFile.kt") public void testFindAssociatedObjectInSeparatedFile() throws Exception { runTest("js/js.translator/testData/box/reflection/findAssociatedObjectInSeparatedFile.kt"); } } + + @Nested + @TestMetadata("js/js.translator/testData/box/kotlin.test") + @TestDataPath("$PROJECT_ROOT") + public class Kotlin_test { + @Test + public void testAllFilesPresentInKotlin_test() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("js/js.translator/testData/box/kotlin.test"), Pattern.compile("^([^_](.+))\\.kt$"), null, TargetBackend.WASM, true); + } + + @Test + @TestMetadata("beforeAfter.kt") + public void testBeforeAfter() throws Exception { + runTest("js/js.translator/testData/box/kotlin.test/beforeAfter.kt"); + } + + @Test + @TestMetadata("ignore.kt") + public void testIgnore() throws Exception { + runTest("js/js.translator/testData/box/kotlin.test/ignore.kt"); + } + + @Test + @TestMetadata("illegalParameters.kt") + public void testIllegalParameters() throws Exception { + runTest("js/js.translator/testData/box/kotlin.test/illegalParameters.kt"); + } + + @Test + @TestMetadata("incremental.kt") + public void testIncremental() throws Exception { + runTest("js/js.translator/testData/box/kotlin.test/incremental.kt"); + } + + @Test + @TestMetadata("inherited.kt") + public void testInherited() throws Exception { + runTest("js/js.translator/testData/box/kotlin.test/inherited.kt"); + } + + @Test + @TestMetadata("mpp.kt") + public void testMpp() throws Exception { + runTest("js/js.translator/testData/box/kotlin.test/mpp.kt"); + } + + @Test + @TestMetadata("nested.kt") + public void testNested() throws Exception { + runTest("js/js.translator/testData/box/kotlin.test/nested.kt"); + } + + @Test + @TestMetadata("returnTestResult.kt") + public void testReturnTestResult() throws Exception { + runTest("js/js.translator/testData/box/kotlin.test/returnTestResult.kt"); + } + + @Test + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + runTest("js/js.translator/testData/box/kotlin.test/simple.kt"); + } + } }